//! File I/O wrapper for the desktop C API layer.

//!

//! Note: `layout/src/file.rs` provides a more complete file API with

//! proper error types (`FileError`) and a `FilePath` wrapper.

use alloc::sync::Arc;

use core::fmt;

use std::{

    fs,

    io::{Read, Write},

    sync::Mutex,

};

use azul_css::{impl_option, impl_option_inner, AzString, U8Vec};

/// Thread-safe file handle with path tracking for the C API.

#[repr(C)]

pub struct File {

    pub ptr: Box<Arc<Mutex<fs::File>>>,

    pub path: AzString,

    pub run_destructor: bool,

}

impl Clone for File {

}

impl Drop for File {

}

impl fmt::Debug for File {

}

impl fmt::Display for File {

}

impl PartialEq for File {

}

impl Eq for File {}

impl PartialOrd for File {

}

impl_option!(File, OptionFile, copy = false, [Clone, Debug]);

impl File {

    /// Opens a file in read-only mode, returning `None` on failure.

        ))

    /// Creates a file (truncating if it exists), returning `None` on failure.

        ))

    /// Reads the file at `self.path` into a string.

    /// Reads the file at `self.path` into a byte vector.

    /// Writes a string to the file handle. Returns `false` on failure.

    /// Writes bytes to the file handle and syncs to disk. Returns `false` on failure.

        };

    /// Closes the file by dropping the handle. Provided for C API symmetry.

}

#[cfg(test)]

mod autotest_generated {

    use core::sync::atomic::{AtomicUsize, Ordering};

    use std::path::PathBuf;

    use super::*;

    // NOTE ON THE TWO HALVES OF THIS TYPE

    //

    // `File` is really two things glued together:

    //   * a live `fs::File` handle behind `Arc<Mutex<_>>` -- this is what `write_bytes`

    //     (and therefore `write_string`) talks to, and

    //   * a `path: AzString` -- this is what `read_to_string` / `read_to_bytes` /

    //     `Debug` / `Display` / `PartialEq` / `PartialOrd` talk to.

    //

    // The two halves can disagree (path deleted under an open handle, path never

    // pointing at the handle at all -- `File::new` accepts *any* AzString), so most

    // tests below deliberately probe the seam rather than the happy path.

    /// A temp path that unlinks itself on drop, so a failing assert can't leak files.

    struct TempPath(PathBuf);

    impl TempPath {

        fn new(tag: &str) -> Self {

            Self(unique_temp_path(tag))

        }

        fn as_str(&self) -> &str {

            self.0.to_str().expect("temp dir must be valid UTF-8")

        }

        fn exists(&self) -> bool {

            self.0.exists()

        }

    }

    impl Drop for TempPath {

        fn drop(&mut self) {

            let _ = fs::remove_file(&self.0);

        }

    }

    fn unique_temp_path(tag: &str) -> PathBuf {

        static COUNTER: AtomicUsize = AtomicUsize::new(0);

        let n = COUNTER.fetch_add(1, Ordering::Relaxed);

        let nanos = std::time::SystemTime::now()

            .duration_since(std::time::UNIX_EPOCH)

            .map_or(0, |d| d.as_nanos());

        std::env::temp_dir().join(format!(

            "azul_autotest_file_{}_{}_{}_{}",

            std::process::id(),

            nanos,

            n,

            tag

        ))

    }

    /// A real, open `fs::File` handle whose path is already gone -- lets us build a

    /// `File` with a *completely arbitrary* `path` field for the fmt/cmp tests.

    fn detached_handle() -> fs::File {

        let path = unique_temp_path("detached");

        let handle = fs::File::create(&path).expect("temp dir must be writable");

        let _ = fs::remove_file(&path);

        handle

    }

    fn with_path(path: &str) -> File {

        File::new(detached_handle(), path.to_string().into())

    }

    // ---------------------------------------------------------------- File::new

    #[test]

    fn new_sets_fields_and_arms_the_destructor() {

        let temp = TempPath::new("new_fields");

        let handle = fs::File::create(temp.as_str()).expect("create");

        let file = File::new(handle, temp.as_str().to_string().into());

        assert_eq!(file.path.as_str(), temp.as_str());

        assert!(file.run_destructor, "a freshly built File must own its handle");

        assert_eq!(

            Arc::strong_count(&file.ptr),

            1,

            "an un-cloned File must be the sole owner of the handle"

        );

    }

    #[test]

    fn new_accepts_extreme_paths_without_panicking() {

        // `new` never touches the filesystem, so even a path that could never exist

        // must be stored verbatim rather than validated/normalized/truncated.

        for path in [

            "",

            "   ",

            "\u{0}embedded-nul",

            "\u{1F600}\u{0301}",

            "relative/../../../etc/passwd",

        ] {

            let file = with_path(path);

            assert_eq!(file.path.as_str(), path, "path must be stored verbatim");

            assert!(file.run_destructor);

        }

        let huge = "x".repeat(100_000);

        assert_eq!(with_path(&huge).path.as_str().len(), 100_000);

    }

    // --------------------------------------------------------------- File::open

    #[test]

    fn open_empty_path_returns_none() {

        assert!(File::open("").is_none());

    }

    #[test]

    fn open_whitespace_only_path_is_not_trimmed_into_something_valid() {

        for path in ["   ", "\t\n", " ", "\r\n\t "] {

            assert!(

                File::open(path).is_none(),

                "whitespace-only path {path:?} must not open anything"

            );

        }

    }

    #[test]

    fn open_missing_path_returns_none() {

        let temp = TempPath::new("never_created");

        assert!(!temp.exists());

        assert!(File::open(temp.as_str()).is_none());

    }

    #[test]

    fn open_garbage_path_returns_none_without_panicking() {

        // Interior NUL cannot be turned into a CString -> must surface as None, not a panic.

        for path in [

            "\u{0}",

            "abc\u{0}def",

            // NOTE: "//////" is deliberately NOT here -- POSIX collapses a run of

            // slashes to "/", and opening the root directory read-only legitimately

            // succeeds. It is not garbage.

            "::**?<>|\"",

            "\u{FFFD}\u{202E}\u{200B}",

        ] {

            assert!(

                File::open(path).is_none(),

                "garbage path {path:?} must return None"

            );

        }

    }

    #[test]

    fn open_boundary_number_paths_return_none() {

        for name in [

            "0",

            "-0",

            "9223372036854775807",

            "-9223372036854775808",

            "18446744073709551616",

            "NaN",

            "inf",

            "-inf",

            "1e400",

            "0.0000000000000000000001",

        ] {

            let path = std::env::temp_dir().join(format!("azul_autotest_missing_{name}"));

            let path = path.to_str().expect("utf-8 temp dir");

            assert!(

                File::open(path).is_none(),

                "numeric-looking missing path {path:?} must return None"

            );

        }

    }

    #[test]

    fn open_extremely_long_path_returns_none_and_terminates() {

        let path = "a".repeat(1_000_000);

        assert!(

            File::open(&path).is_none(),

            "a 1M-char path is over every OS limit and must fail cleanly"

        );

    }

    #[test]

    fn open_deeply_nested_path_does_not_stack_overflow() {

        // 10_000 nested segments -- exercises the "recursive input" case for a path parser.

        let mut path = String::with_capacity(20_002);

        for _ in 0..10_000 {

            path.push_str("a/");

        }

        path.push('x');

        assert!(File::open(&path).is_none());

    }

    #[test]

    fn open_directory_never_yields_readable_content() {

        // On unix, open(2) on a directory succeeds, so `File::open` hands back a `File`

        // whose handle is a directory. Reading through it must still fail cleanly.

        let dir = std::env::temp_dir();

        let dir = dir.to_str().expect("utf-8 temp dir");

        if let Some(mut file) = File::open(dir) {

            assert_eq!(file.path.as_str(), dir);

            assert!(

                file.read_to_string().is_none(),

                "a directory must not read back as a string"

            );

            assert!(

                file.read_to_bytes().is_none(),

                "a directory must not read back as bytes"

            );

        }

    }

    #[test]

    fn open_is_read_only_so_writes_fail_and_leave_content_intact() {

        let temp = TempPath::new("readonly");

        {

            let mut file = File::create(temp.as_str()).expect("create");

            assert!(file.write_string("original"));

        }

        let mut file = File::open(temp.as_str()).expect("open existing file");

        assert!(

            !file.write_string("clobbered"),

            "writing through a read-only handle must return false, not panic"

        );

        assert!(!file.write_bytes(b"clobbered"));

        assert_eq!(

            file.read_to_string().expect("read back").as_str(),

            "original",

            "a failed write must not have corrupted the file"

        );

    }

    // ------------------------------------------------------------- File::create

    #[test]

    fn create_empty_path_returns_none() {

        assert!(File::create("").is_none());

    }

    #[test]

    fn create_in_missing_directory_returns_none() {

        let dir = unique_temp_path("missing_dir");

        let path = dir.join("child.txt");

        let path = path.to_str().expect("utf-8 temp dir");

        assert!(File::create(path).is_none());

    }

    #[test]

    fn create_over_a_directory_returns_none() {

        let dir = std::env::temp_dir();

        let dir = dir.to_str().expect("utf-8 temp dir");

        assert!(

            File::create(dir).is_none(),

            "create() must refuse to truncate a directory"

        );

    }

    #[test]

    fn create_garbage_path_returns_none_without_panicking() {

        let over_long = "z".repeat(1_000_000);

        for path in ["\u{0}", "bad\u{0}name", "", over_long.as_str()] {

            assert!(

                File::create(path).is_none(),

                "create() of a {}-char garbage path must return None",

                path.len()

            );

        }

    }

    #[test]

    fn create_truncates_existing_content() {

        let temp = TempPath::new("truncate");

        {

            let mut file = File::create(temp.as_str()).expect("create");

            assert!(file.write_string("a fairly long pre-existing payload"));

        }

        let mut file = File::create(temp.as_str()).expect("re-create");

        assert_eq!(

            file.read_to_string().expect("read back").as_str(),

            "",

            "create() must truncate an existing file to zero bytes"

        );

    }

    // ------------------------------------------------------- write/read round-trips

    #[test]

    fn round_trip_representative_string() {

        let temp = TempPath::new("round_trip");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string("hello world"));

        assert_eq!(file.read_to_string().expect("read").as_str(), "hello world");

        assert_eq!(file.read_to_bytes().expect("read").as_slice(), b"hello world");

        // ...and the same content survives a close + reopen cycle.

        file.close();

        let mut reopened = File::open(temp.as_str()).expect("reopen");

        assert_eq!(reopened.read_to_string().expect("read").as_str(), "hello world");

    }

    #[test]

    fn round_trip_empty_write_produces_an_empty_file() {

        let temp = TempPath::new("empty_write");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_bytes(&[]), "writing zero bytes must still succeed");

        assert!(file.write_string(""));

        assert_eq!(file.read_to_string().expect("read").as_str(), "");

        assert_eq!(file.read_to_bytes().expect("read").len(), 0);

    }

    #[test]

    fn round_trip_unicode_content() {

        let content = "\u{1F600} héllo e\u{0301} \u{202E}rtl\u{202C} \u{0}nul \r\n mixed";

        let temp = TempPath::new("unicode_content");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string(content));

        assert_eq!(file.read_to_string().expect("read").as_str(), content);

        assert_eq!(

            file.read_to_bytes().expect("read").as_slice(),

            content.as_bytes(),

            "byte round-trip must be exact for multibyte content"

        );

    }

    #[test]

    fn round_trip_unicode_path() {

        let temp = TempPath::new("p\u{1F600}_h\u{0301}ll\u{00F6}");

        let mut file = File::create(temp.as_str()).expect("create with unicode path");

        assert_eq!(file.path.as_str(), temp.as_str());

        assert!(file.write_string("ok"));

        assert_eq!(file.read_to_string().expect("read").as_str(), "ok");

        let reopened = File::open(temp.as_str()).expect("reopen unicode path");

        assert_eq!(reopened.path.as_str(), temp.as_str());

        assert_eq!(reopened, file, "equality is path-based, so these must match");

    }

    #[test]

    fn round_trip_all_256_byte_values_and_invalid_utf8_reads_as_none() {

        let bytes: Vec<u8> = (0..=255u8).collect();

        let temp = TempPath::new("all_bytes");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_bytes(&bytes));

        assert_eq!(

            file.read_to_bytes().expect("read").as_slice(),

            bytes.as_slice(),

            "every byte value must survive the round-trip untouched"

        );

        assert!(

            file.read_to_string().is_none(),

            "non-UTF-8 content must return None, never a lossy string or a panic"

        );

    }

    #[test]

    fn round_trip_one_mib_payload() {

        let bytes = vec![0xABu8; 1024 * 1024];

        let temp = TempPath::new("one_mib");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_bytes(&bytes));

        let read = file.read_to_bytes().expect("read");

        assert_eq!(read.len(), bytes.len());

        assert_eq!(read.as_slice(), bytes.as_slice());

    }

    #[test]

    fn writes_append_at_the_handle_cursor_rather_than_overwriting() {

        let temp = TempPath::new("append_cursor");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string("a"));

        assert!(file.write_string("bc"));

        assert!(file.write_bytes(b"d"));

        assert_eq!(

            file.read_to_string().expect("read").as_str(),

            "abcd",

            "consecutive writes advance the cursor; none of them rewind"

        );

    }

    #[test]

    fn reads_follow_the_path_not_the_handle() {

        // The seam: `read_*` re-opens `self.path` from scratch, so out-of-band changes

        // to the path are visible and the handle's cursor position is irrelevant.

        let temp = TempPath::new("path_vs_handle");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string("written through the handle"));

        fs::write(temp.as_str(), "replaced out of band").expect("out-of-band write");

        assert_eq!(

            file.read_to_string().expect("read").as_str(),

            "replaced out of band"

        );

    }

    #[test]

    fn reads_return_none_after_the_path_is_deleted_under_an_open_handle() {

        let temp = TempPath::new("deleted_under_handle");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string("content"));

        fs::remove_file(temp.as_str()).expect("unlink");

        assert!(

            file.read_to_string().is_none(),

            "reads go through the path, which is now gone"

        );

        assert!(file.read_to_bytes().is_none());

        // The handle itself is still alive, so writes to it must still succeed.

        assert!(

            file.write_string("still writable"),

            "an unlinked-but-open handle is still writable on unix"

        );

    }

    #[test]

    fn read_and_write_on_a_file_whose_path_never_existed() {

        // `File::new` is happy to pair a live handle with a bogus path. Reads must then

        // fail cleanly while writes (which use the handle) still work.

        let mut file = with_path("/this/path/does/not/exist\u{1F600}");

        assert!(file.read_to_string().is_none());

        assert!(file.read_to_bytes().is_none());

        assert!(file.write_string("goes to the detached handle"));

        let mut empty_path = with_path("");

        assert!(empty_path.read_to_string().is_none());

        assert!(empty_path.read_to_bytes().is_none());

    }

    #[test]

    fn write_bytes_returns_false_on_a_poisoned_mutex() {

        let temp = TempPath::new("poisoned");

        let mut file = File::create(temp.as_str()).expect("create");

        let arc = (*file.ptr).clone();

        let joined = std::thread::spawn(move || {

            let _guard = arc.lock().expect("first lock cannot be poisoned");

            panic!("intentional panic to poison the file mutex");

        })

        .join();

        assert!(joined.is_err(), "the helper thread must have panicked");

        assert!(

            !file.write_bytes(b"nope"),

            "a poisoned mutex must surface as `false`, not as an unwrap panic"

        );

        assert!(!file.write_string("nope"));

    }

    // --------------------------------------------------- Clone / Drop / close

    #[test]

    fn clone_shares_the_handle_and_the_path() {

        let temp = TempPath::new("clone_shares");

        let mut file = File::create(temp.as_str()).expect("create");

        let mut clone = file.clone();

        assert_eq!(Arc::strong_count(&file.ptr), 2, "clone must share the Arc");

        assert!(clone.run_destructor);

        assert_eq!(clone, file);

        // Both halves write into the same cursor, so the writes interleave in order.

        assert!(file.write_string("a"));

        assert!(clone.write_string("b"));

        assert!(file.write_string("c"));

        assert_eq!(file.read_to_string().expect("read").as_str(), "abc");

    }

    #[test]

    fn close_drops_only_one_owner_and_leaves_the_content_on_disk() {

        let temp = TempPath::new("close");

        let mut file = File::create(temp.as_str()).expect("create");

        assert!(file.write_string("persisted"));

        let clone = file.clone();

        clone.close();

        assert_eq!(

            Arc::strong_count(&file.ptr),

            1,

            "closing a clone must release exactly one Arc reference"

        );

        // The surviving handle still works, and the bytes are still on disk.

        assert!(file.write_string("!"));

        assert_eq!(file.read_to_string().expect("read").as_str(), "persisted!");

        file.close();

        let mut reopened = File::open(temp.as_str()).expect("reopen after close");

        assert_eq!(reopened.read_to_string().expect("read").as_str(), "persisted!");

    }

    #[test]

    fn close_on_an_extreme_file_does_not_panic() {

        with_path("").close();

        with_path(&"q".repeat(100_000)).close();

        with_path("\u{1F600}\u{0}\u{202E}").close();

    }

    // ------------------------------------------------- Debug / Display / Eq / Ord

    #[test]

    fn debug_and_display_render_exactly_the_path() {

        // Includes format-specifier-looking payloads: these must be printed literally,

        // never interpreted, and never truncated.

        for path in [

            "/tmp/plain.txt",

            "",

            "{}",

            "{0} {:?} %s %n",

            "\u{1F600} h\u{00E9}llo e\u{0301}",

            "line\nbreak\ttab",

        ] {

            let file = with_path(path);

            assert_eq!(format!("{file}"), path, "Display must echo the path verbatim");

            assert_eq!(format!("{file:?}"), path, "Debug must echo the path verbatim");

            assert_eq!(

                format!("{file}"),

                format!("{file:?}"),

                "Debug and Display must agree"

            );

        }

    }

    #[test]

    fn display_is_non_empty_for_a_real_file_and_idempotent() {

        let temp = TempPath::new("display_stable");

        let file = File::create(temp.as_str()).expect("create");

        let once = format!("{file}");

        assert!(!once.is_empty());

        assert_eq!(once, temp.as_str());

        // Re-rendering the re-parsed value is stable (serialize . parse . serialize == serialize).

        let reopened = File::open(&once).expect("the rendered path must reopen the same file");

        assert_eq!(format!("{reopened}"), once);

        assert_eq!(reopened, file);

    }

    #[test]

    fn display_of_a_huge_path_is_not_truncated() {

        let path = "w".repeat(300_000);

        let file = with_path(&path);

        assert_eq!(format!("{file}").len(), 300_000);

    }

    #[test]

    fn eq_and_ord_are_purely_path_based() {

        let a1 = with_path("a");

        let a2 = with_path("a"); // different handle, same path

        let b = with_path("b");

        assert_eq!(a1, a2, "equality ignores the handle entirely");

        assert_ne!(a1, b);

        assert_eq!(a1.partial_cmp(&a2), Some(core::cmp::Ordering::Equal));

        assert_eq!(a1.partial_cmp(&b), Some(core::cmp::Ordering::Less));

        assert_eq!(b.partial_cmp(&a1), Some(core::cmp::Ordering::Greater));

        assert!(a1 < b);

        // Ordering must track `str` ordering (byte-wise), including for multibyte paths.

        let empty = with_path("");

        let emoji = with_path("\u{1F600}");

        assert_eq!(empty.partial_cmp(&emoji), "".partial_cmp("\u{1F600}"));

        assert_eq!(emoji.partial_cmp(&empty), "\u{1F600}".partial_cmp(""));

        assert_eq!(emoji.partial_cmp(&emoji.clone()), Some(core::cmp::Ordering::Equal));

        // Reflexive / symmetric on a clone (which shares the handle).

        let cloned = a1.clone();

        assert_eq!(a1, cloned);

        assert_eq!(cloned, a1);

    }

    #[test]

    fn option_file_round_trips_through_the_ffi_option() {

        assert!(matches!(OptionFile::default(), OptionFile::None));

        assert!(OptionFile::default().as_option().is_none());

        let none: OptionFile = Option::<File>::None.into();

        assert!(Option::<File>::from(none).is_none());

        let file = with_path("\u{1F600}/round/trip");

        let ffi: OptionFile = Some(file).into();

        assert_eq!(

            ffi.as_option().expect("Some").path.as_str(),

            "\u{1F600}/round/trip"

        );

        let back = Option::<File>::from(ffi).expect("Some survives the round-trip");

        assert_eq!(back.path.as_str(), "\u{1F600}/round/trip");

        assert!(back.run_destructor);

    }

}