//! Scripted mission acceptance uses synthetic PNG/WAV and native-ID placeholders.
//! This does not validate original-catalog enemy paths, guns, or native-wave balance.
use raptor_replica::{
    content::{ContentPack, Registry},
    modding::{self, ActiveMods, Manifest},
    persistence::Pilot,
    simulation::{Input, Outcome, World},
};
use serde_json::{Value, json};
use std::{
    fs,
    path::{Path, PathBuf},
};

const PACKAGES: [&str; 8] = [
    "iron_coast_music",
    "iron_coast_scout",
    "iron_coast_turret",
    "iron_coast_boss",
    "pulse_cannon",
    "seeker_swarm",
    "ion_lance",
    "iron_coast_mission_1",
];
const MISSION: &str = "iron_coast_mission_1:mission_01";

fn base() -> Registry {
    let mut registry = Registry::default();
    let mut value = json!({
        "weapons":[{"id":"base:projectile_forward_guns","name":"Forward Guns","damage":1,"speed":8,"cooldown":2,"behavior":"straight","target":"all","legacy":0,"art":{"asset":42,"logical_width":4,"logical_height":8,"frames":4}}],
        "items":[{"id":"base:forward_guns","name":"Forward Guns","price":0,"max_count":1,"weapon":"base:projectile_forward_guns","legacy":0},{"id":"base:energy","name":"Shield","price":0,"max_count":100,"legacy":16}],
        "missions":[{"id":"base:sector_1_wave_1","name":"Base fixture","duration":1000}]
    });
    for n in 0..18 {
        value["items"].as_array_mut().unwrap().push(json!({"id":format!("base:fixture_item_{n}"),"name":"Synthetic equipment","price":0,"max_count":1}));
    }
    // Native wave references were added by the retune. Keep these portable
    // fixtures explicitly synthetic; real native behavior belongs to catalog tests.
    value["enemies"] = json!([21, 22, 73, 74].map(|id| json!({
        "id":format!("base:enemy_0_{id}"), "name":"Synthetic native-ID placeholder",
        "health":1, "speed":1
    })));
    let pack: ContentPack = serde_json::from_value(value).unwrap();
    registry.apply(pack, "base").unwrap();
    registry.validate().unwrap();
    registry
}

fn fixture_resources(value: &Value, root: &Path, original: &Path) {
    match value {
        Value::Object(object) => {
            if let (Some(width), Some(height)) = (
                object.get("logical_width").and_then(Value::as_u64),
                object.get("logical_height").and_then(Value::as_u64),
            ) {
                let frames = object.get("frames").and_then(Value::as_u64).unwrap_or(1);
                for (key, scale) in [("png", 1), ("hd_png", 4)] {
                    if let Some(file) = object.get(key).and_then(Value::as_str) {
                        let path = root.join(file);
                        fs::create_dir_all(path.parent().unwrap()).unwrap();
                        let image = image::RgbaImage::from_pixel(
                            (width * frames * scale) as u32,
                            (height * scale) as u32,
                            image::Rgba([80, 96, 104, 255]),
                        );
                        image.save(path).unwrap();
                    }
                }
            }
            if let Some(file) = object.get("file").and_then(Value::as_str) {
                let path = root.join(file);
                fs::create_dir_all(path.parent().unwrap()).unwrap();
                if Path::new(file).extension().is_some_and(|ext| ext == "mus") {
                    fs::copy(original.join(file), &path).unwrap();
                    return;
                }
                // Small valid mono PCM16 WAV; integration checks use the actual cues.
                let mut wav = Vec::new();
                wav.extend_from_slice(b"RIFF");
                wav.extend_from_slice(&100_u32.to_le_bytes());
                wav.extend_from_slice(b"WAVEfmt ");
                wav.extend_from_slice(&16_u32.to_le_bytes());
                wav.extend_from_slice(&1_u16.to_le_bytes());
                wav.extend_from_slice(&1_u16.to_le_bytes());
                wav.extend_from_slice(&22050_u32.to_le_bytes());
                wav.extend_from_slice(&44100_u32.to_le_bytes());
                wav.extend_from_slice(&2_u16.to_le_bytes());
                wav.extend_from_slice(&16_u16.to_le_bytes());
                wav.extend_from_slice(b"data");
                wav.extend_from_slice(&64_u32.to_le_bytes());
                wav.extend_from_slice(&[0; 64]);
                fs::write(path, wav).unwrap();
            }
            for child in object.values() {
                fixture_resources(child, root, original);
            }
        }
        Value::Array(values) => {
            for child in values {
                fixture_resources(child, root, original);
            }
        }
        _ => {}
    }
}

fn active() -> (tempfile::TempDir, ActiveMods) {
    let started = std::time::Instant::now();
    let temporary = tempfile::tempdir().unwrap();
    let source = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("mods");
    for id in PACKAGES {
        let original = source.join(id);
        let root = temporary.path().join(id);
        fs::create_dir_all(&root).unwrap();
        let manifest_data = fs::read(original.join("mod.toml"))
            .expect("all eight Breakwater packages must be installed");
        let manifest: Manifest =
            toml::from_str(std::str::from_utf8(&manifest_data).unwrap()).unwrap();
        fs::write(root.join("mod.toml"), manifest_data).unwrap();
        let content = fs::read(original.join(&manifest.content)).unwrap();
        let value: Value = serde_json::from_slice(&content).unwrap();
        fs::write(root.join(&manifest.content), content).unwrap();
        for script in &manifest.scripts {
            let path = root.join(script);
            fs::create_dir_all(path.parent().unwrap()).unwrap();
            fs::copy(original.join(script), path).unwrap();
        }
        fixture_resources(&value, &root, &original);
    }
    let discovery = modding::discover(temporary.path());
    assert!(discovery.errors.is_empty(), "{:?}", discovery.errors);
    let enabled = PACKAGES.iter().map(|s| s.to_string()).collect::<Vec<_>>();
    let active = ActiveMods::build(&base(), &discovery, &enabled, None).unwrap();
    eprintln!(
        "Iron Coast synthetic eight-package activation: {:.3}s",
        started.elapsed().as_secs_f64()
    );
    (temporary, active)
}

#[test]
fn campaign_dependencies_and_generated_footprints_validate_together() {
    let (_temporary, active) = active();
    assert_eq!(active.pins.len(), 8);
    let mission = &active.registry.missions[&MISSION.into()];
    assert!(!mission.auto_complete);
    assert_eq!(mission.columns, 9);
    assert_eq!(mission.layout.len(), 72 * 9);
    assert!(
        mission
            .spawns
            .iter()
            .any(|s| s.enemy.0 == "iron_coast_boss:unit" && s.tick == 720)
    );
    assert_eq!(mission.art.as_ref().unwrap().logical_width, 320);
    assert!(
        active.registry.campaigns[&"iron_coast_mission_1:campaign".into()]
            .missions
            .contains(&MISSION.into())
    );
}

#[test]
fn boss_alone_cannot_complete_and_reward_is_paid_once() {
    let (_temporary, mut active) = active();
    let mut world = World::new(&MISSION.into(), &Pilot::default(), &active.registry).unwrap();
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    world
        .objectives
        .insert("iron_coast_boss:defeated".into(), 1);
    world
        .objectives
        .insert("iron_coast_turret:defeated".into(), 1);
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    assert_eq!(world.outcome, Outcome::Playing);
    world
        .objectives
        .insert("iron_coast_turret:defeated".into(), 2);
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    assert_eq!(world.outcome, Outcome::Complete);
    assert_eq!(world.objectives["iron_coast_mission_1:complete"], 1);
    assert_eq!(world.player.credits, 5000);
    assert_eq!(world.objectives["iron_coast_mission_1:debrief"], 1);
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    assert_eq!(world.player.credits, 5000);
}

#[test]
fn missed_breakwater_objective_turrets_stay_reachable() {
    let (_temporary, mut active) = active();
    let mut world = World::new(&MISSION.into(), &Pilot::default(), &active.registry).unwrap();
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    let target = world
        .spawn(&"iron_coast_turret:unit".into(), 40, 71, &active.registry)
        .unwrap();
    for _ in 0..60 {
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        let turret = world
            .enemies
            .iter()
            .find(|unit| unit.entity == target)
            .unwrap();
        assert_eq!(turret.y, 72);
        assert!(turret.health > 0);
        assert_eq!(world.outcome, Outcome::Playing);
    }
}

fn play(use_trial: bool) -> (World, Vec<(u64, String)>) {
    let (_temporary, mut active) = active();
    let mut world = World::new(&MISSION.into(), &Pilot::default(), &active.registry).unwrap();
    let mut seen = Vec::new();
    for tick in 0..2000 {
        let input = Input {
            fire: true,
            special: tick % 90 == 60,
            cycle: tick == 1,
            absolute: Some([144, 160]),
            ..Input::default()
        };
        world
            .step(input, &active.registry, &mut active.scripts)
            .unwrap();
        if tick == 0 && !use_trial {
            world
                .player
                .inventory
                .remove(&"pulse_cannon:equipment".into());
        }
        for enemy in &world.enemies {
            if !seen.iter().any(|(_, id)| id == &enemy.definition.0) {
                seen.push((world.tick, enemy.definition.0.clone()));
            }
        }
        if world.outcome != Outcome::Playing {
            break;
        }
    }
    if use_trial {
        let weapon_state = &active.scripts.states["pulse_cannon/scripts/weapon.rhai"];
        assert!(weapon_state["bursts"].as_i64().unwrap() > 0);
        assert!(weapon_state["hits"].as_i64().unwrap() > 0);
        let serialized = serde_json::to_string(&active.scripts.states).unwrap();
        let recovered: serde_json::Value = serde_json::from_str(&serialized).unwrap();
        assert_eq!(recovered["pulse_cannon/scripts/weapon.rhai"], *weapon_state);
    }
    eprintln!(
        "Iron Coast {} run: tick={} outcome={:?} shield={} credits={} repairs_remaining={}",
        if use_trial {
            "trial Pulse"
        } else {
            "starter guns"
        },
        world.tick,
        world.outcome,
        world.player.shield,
        world.player.credits,
        world
            .player
            .inventory
            .get(&"iron_coast_mission_1:repair".into())
            .copied()
            .unwrap_or(0)
    );
    (world, seen)
}

#[test]
fn full_inventory_can_start_without_deleting_saved_equipment() {
    let (_temporary, mut active) = active();
    for reserves in [0, 4] {
        let mut pilot = Pilot::default();
        if reserves > 0 {
            pilot.inventory.insert("base:super_shield".into(), 100);
            pilot.super_shield_reserves = vec![100; reserves];
        }
        while pilot.inventory_slots() < 20 {
            let n = pilot.inventory.len();
            pilot
                .inventory
                .insert(format!("base:fixture_item_{n}").as_str().into(), 1);
        }
        assert_eq!(pilot.inventory_slots(), 20);
        let mut world = World::new(&MISSION.into(), &pilot, &active.registry).unwrap();
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        assert_eq!(world.player.inventory, pilot.inventory);
        assert_eq!(
            world.player.super_shield_reserves,
            pilot.super_shield_reserves
        );
        assert_eq!(world.objectives["iron_coast_mission_1:trial_issued"], 0);
        assert_eq!(world.outcome, Outcome::Playing);
    }
}

#[test]
fn restarted_mission_counts_new_turret_kills_independently_of_saved_statistics() {
    let (_temporary, mut active) = active();
    for _ in 0..2 {
        let mut world = World::new(&MISSION.into(), &Pilot::default(), &active.registry).unwrap();
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        let entity = world
            .spawn(&"iron_coast_turret:unit".into(), 144, 0, &active.registry)
            .unwrap();
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        world
            .apply_commands(
                &[modding::Command::Damage {
                    entity,
                    amount: 1000,
                }],
                &active.registry,
            )
            .unwrap();
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        assert_eq!(world.objectives["iron_coast_turret:defeated"], 1);
        assert_eq!(world.outcome, Outcome::Playing);
    }
    assert_eq!(
        active.scripts.states["iron_coast_turret/scripts/ai.rhai"]["destroyed"],
        2
    );
}

#[test]
fn starter_guns_complete_scripted_waves_and_boss_with_synthetic_native_fillers() {
    let (world, seen) = play(false);
    assert_eq!(
        world.outcome,
        Outcome::Complete,
        "tick={} shield={} objectives={:?}",
        world.tick,
        world.player.shield,
        world.objectives
    );
    assert!(
        seen.iter()
            .any(|(tick, id)| *tick >= 720 && id == "iron_coast_boss:unit")
    );
    assert!(world.objectives["iron_coast_turret:defeated"] >= 2);
    assert!(world.objectives["iron_coast_boss:defeated"] >= 1);
    assert_eq!(world.objectives["iron_coast_mission_1:phase"], 4);
    assert!(world.player.shield > 0);
    assert!(world.tick > 720 && world.tick < 2000);
}

#[test]
fn trial_pulse_cannon_completes_and_preserves_scripted_weapon_state() {
    let (world, _seen) = play(true);
    assert_eq!(
        world.outcome,
        Outcome::Complete,
        "tick={} shield={} objectives={:?}",
        world.tick,
        world.player.shield,
        world.objectives
    );
    assert!(
        !world
            .player
            .inventory
            .contains_key(&"pulse_cannon:equipment".into())
    );
    assert!(world.player.credits >= 5000);
}

#[test]
fn trial_is_a_loan_and_cannot_be_repeatedly_sold_after_victory() {
    let (_temporary, mut active) = active();
    let mut pilot = Pilot::default();
    for _ in 0..2 {
        let mut world = World::new(&MISSION.into(), &pilot, &active.registry).unwrap();
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        assert_eq!(world.player.inventory[&"pulse_cannon:equipment".into()], 1);
        world
            .objectives
            .insert("iron_coast_turret:defeated".into(), 2);
        world
            .objectives
            .insert("iron_coast_boss:defeated".into(), 1);
        world
            .step(Input::default(), &active.registry, &mut active.scripts)
            .unwrap();
        assert_eq!(world.outcome, Outcome::Complete);
        pilot = world.pilot(&pilot);
        assert!(
            !pilot
                .inventory
                .contains_key(&"pulse_cannon:equipment".into())
        );
        let credits = pilot.credits;
        assert!(
            pilot
                .sell(&"pulse_cannon:equipment".into(), &active.registry)
                .is_err()
        );
        assert_eq!(pilot.credits, credits);
    }
}

#[test]
fn owned_cannon_survives_trial_completion_without_replacement() {
    let (_temporary, mut active) = active();
    let mut pilot = Pilot::default();
    pilot.inventory.insert("pulse_cannon:equipment".into(), 1);
    let mut world = World::new(&MISSION.into(), &pilot, &active.registry).unwrap();
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    world
        .objectives
        .insert("iron_coast_turret:defeated".into(), 2);
    world
        .objectives
        .insert("iron_coast_boss:defeated".into(), 1);
    world
        .step(Input::default(), &active.registry, &mut active.scripts)
        .unwrap();
    assert_eq!(world.outcome, Outcome::Complete);
    assert_eq!(world.player.inventory[&"pulse_cannon:equipment".into()], 1);
}