use super::{
    Fixture,
    fixture::{archive, hash, signed},
};
use dever::compiler::project::dependency::{
    Lock, Store,
    library::{
        Spec,
        lock::{Artifact, Library, Runtime},
        npm::Environment,
    },
};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::collections::{BTreeMap, BTreeSet};

// Fixture 按既有 v6 协议编码，独立于实现中的私有 Receipt 类型。
#[derive(Deserialize, Serialize)]
struct Inputs {
    format: String,
    toolchain: String,
    libs: Vec<Library>,
    workers: Vec<Value>,
    npm: Vec<Environment>,
}

#[derive(Deserialize, Serialize)]
struct Tools {
    format: String,
    ecosystem: String,
    target: String,
    runtime_sha256: String,
    python_runtime_sha256: Option<String>,
    sha256: String,
}

#[derive(Serialize)]
struct Receipt {
    ecosystem: String,
    roots: Vec<Spec>,
    sources: Vec<Artifact>,
    graph: Option<Environment>,
    runtime: Runtime,
    auxiliary_runtime: Option<Runtime>,
    native_entries: BTreeSet<String>,
    native_rejections: BTreeMap<String, String>,
    python_markers: Option<Value>,
    tools: Tools,
    frontend: String,
    python: Option<Value>,
    dynamic_requires: Vec<String>,
    inputs: Inputs,
    config_settings: BTreeMap<String, Value>,
    output: Artifact,
}

fn prepare(fixture: &mut Fixture, addons: bool) -> Receipt {
    let node_pack = archive(&BTreeMap::from([(
        "fixture/node.txt".into(),
        b"author fixture runtime".to_vec(),
    )]));
    let python_pack = archive(&BTreeMap::from([(
        "fixture/python.txt".into(),
        b"author fixture auxiliary runtime".to_vec(),
    )]));
    let build_pack = archive(&BTreeMap::from([(
        "fixture/tools.txt".into(),
        b"already prepared output; no hooks run".to_vec(),
    )]));
    fixture.metadata.pack.sha256 = hash(&node_pack);
    let mut extra = BTreeMap::new();
    if addons {
        extra.insert(
            "package/foreign.node".into(),
            b"prebuilt foreign format".to_vec(),
        );
    }
    fixture.package(
        json!({"name":"built","version":"1.0.0","scripts":{"install":"must never run"}}),
        extra,
    );
    fixture.resolve(&["npm:built@1.0.0"]).unwrap();
    let graph = fixture.graph();
    let mut output = BTreeMap::from([
        (
            "node_modules/built/package.json".into(),
            serde_json::to_vec(
                &json!({"name":"built","version":"1.0.0","scripts":{"install":"must never run"}}),
            )
            .unwrap(),
        ),
        (
            "node_modules/built/generated.js".into(),
            b"module.exports=42".to_vec(),
        ),
    ]);
    if addons {
        output.insert(
            "node_modules/built/foreign.node".into(),
            b"prebuilt foreign format".to_vec(),
        );
    }
    let bytes = archive(&output);
    fixture.put(&bytes).unwrap();
    let python = Runtime {
        name: "python".into(),
        version: "3.12.1".into(),
        sha256: hash(&python_pack),
    };
    let tools = Tools {
        format: "dever-registry-build-v1".into(),
        ecosystem: "npm".into(),
        target: fixture.target.name().into(),
        runtime_sha256: fixture.metadata.pack.sha256.clone(),
        python_runtime_sha256: Some(python.sha256.clone()),
        sha256: hash(&build_pack),
    };
    let target = fixture.target.name();
    let files=BTreeMap::from([
        (format!("runtime/npm/{target}/runtime.pack"),node_pack),
        (format!("runtime/npm/{target}/manifest.json"),serde_json::to_vec(&json!({"format":"dever-registry-runtime-v1","runtime":{"pack":fixture.metadata.pack,"target":target,"python_markers":null,"python_wheel_tags":[],"npm_libc":"glibc"}})).unwrap()),
        (format!("runtime/pip/{target}/runtime.pack"),python_pack),
        (format!("runtime/pip/{target}/manifest.json"),serde_json::to_vec(&json!({"format":"dever-registry-runtime-v1","runtime":{"pack":python,"target":target,"python_markers":{"implementation_name":"cpython","implementation_version":"3.12.1","os_name":"posix","platform_machine":"x86_64","platform_python_implementation":"CPython","platform_release":"","platform_system":"Linux","platform_version":"","python_full_version":"3.12.1","python_version":"3.12","sys_platform":"linux"},"python_wheel_tags":["py3-none-any"]}})).unwrap()),
        (format!("build/npm/{target}/build.pack"),build_pack),
        (format!("build/npm/{target}/manifest.json"),serde_json::to_vec(&tools).unwrap()),
    ]);
    fixture.signed = signed(&fixture.directory, &files);
    Receipt {
        ecosystem: "npm".into(),
        roots: graph.roots.clone(),
        sources: fixture
            .lock
            .libs
            .iter()
            .flat_map(|lib| lib.artifacts.clone())
            .collect(),
        graph: Some(graph),
        runtime: fixture.metadata.pack.clone(),
        auxiliary_runtime: Some(python),
        native_entries: BTreeSet::new(),
        native_rejections: if addons {
            BTreeMap::from([("node_modules/built/foreign.node".into(), "format".into())])
        } else {
            BTreeMap::new()
        },
        python_markers: None,
        tools,
        frontend: "cfe67ebbc939762cd4ba7328943bf97a72d06a4b79071f056ebd8e5ab566a721".into(),
        python: None,
        dynamic_requires: vec![],
        inputs: serde_json::from_value(serde_json::to_value(&fixture.lock).unwrap()).unwrap(),
        config_settings: BTreeMap::new(),
        output: Artifact {
            target: target.into(),
            path: format!("build/npm/{}/installation.tgz", hash(&bytes)),
            bytes: bytes.len() as u64,
            sha256: hash(&bytes),
            source: None,
        },
    }
}

fn attach(fixture: &mut Fixture, receipt: &Receipt) {
    fixture.lock.npm[0]["build"] = json!(hash(&serde_json::to_vec(receipt).unwrap()));
    fixture.lock.builds = vec![serde_json::to_value(receipt).unwrap()];
}

#[test]
fn npm_lifecycle_receipt_consumes_signed_inputs_without_network_or_hooks() {
    let mut fixture = Fixture::new();
    let receipt = prepare(&mut fixture, false);
    attach(&mut fixture, &receipt);
    fixture.documents.clear();
    let calls = fixture.calls.borrow().len();
    let files = fixture.install().unwrap();
    assert_eq!(
        files["node_modules/built/generated.js"],
        b"module.exports=42"
    );
    assert_eq!(fixture.calls.borrow().len(), calls);
    let text = fixture.lock.encode().unwrap();
    let reparsed = Lock::decode(&text).unwrap();
    fixture.lock = reparsed;
    fixture.install().unwrap();
    fixture.lock.builds[0]["frontend"] = json!("0".repeat(64));
    assert!(fixture.install().unwrap_err().contains("receipt"));
}

#[test]
fn npm_native_receipt_accounts_for_all_addons_and_never_admits_failed_build() {
    let mut fixture = Fixture::new();
    let mut receipt = prepare(&mut fixture, true);
    attach(&mut fixture, &receipt);
    assert!(
        !fixture
            .install()
            .unwrap()
            .keys()
            .any(|path| path.ends_with(".node"))
    );
    receipt.native_rejections.clear();
    attach(&mut fixture, &receipt);
    assert!(fixture.install().unwrap_err().contains("admission"));
    receipt
        .native_entries
        .insert("node_modules/built/foreign.node".into());
    attach(&mut fixture, &receipt);
    assert!(fixture.install().unwrap_err().contains("ELF"));
    receipt.native_entries.clear();
    receipt
        .native_rejections
        .insert("node_modules/built/new.node".into(), "unloadable".into());
    attach(&mut fixture, &receipt);
    assert!(fixture.install().unwrap_err().contains("admission"));
}

#[test]
fn npm_replay_rejects_malformed_binding_before_fetching_or_executing() {
    let mut fixture = Fixture::new();
    let mut receipt = prepare(&mut fixture, false);
    receipt.tools.runtime_sha256 = "0".repeat(64);
    attach(&mut fixture, &receipt);
    fixture.cache.borrow_mut().clear();
    let calls = fixture.calls.borrow().len();
    let error = dever::compiler::project::dependency::library::npm::restore(
        &fixture.lock,
        &fixture.graph(),
        fixture.target,
        &fixture.signed,
        &fixture,
        &fixture,
    )
    .unwrap_err();
    assert!(error.contains("binding differs"), "{error}");
    assert_eq!(fixture.calls.borrow().len(), calls);
    assert!(fixture.cache.borrow().is_empty());
}

#[test]
fn npm_cached_receipt_rejects_tampering_but_needs_no_build_tools() {
    let mut fixture = Fixture::new();
    let receipt = prepare(&mut fixture, false);
    attach(&mut fixture, &receipt);
    let original = fixture.cache.borrow()[&receipt.output.sha256].clone();
    fixture
        .cache
        .borrow_mut()
        .insert(receipt.output.sha256.clone(), b"tampered".to_vec());
    assert!(fixture.install().unwrap_err().contains("digest"));
    fixture
        .cache
        .borrow_mut()
        .insert(receipt.output.sha256.clone(), original);
    std::fs::remove_file(fixture.directory.0.join(format!(
        "signed/versions/0.0.1/build/npm/{}/build.pack",
        fixture.target.name()
    )))
    .unwrap();
    fixture.install().unwrap();
}