//! Property tests for spec §7.3: a state is a function of its set of
//! changes, never of the order they arrived in.
//!
//! Each case seeds a repository with a few files, lets two or three clones
//! diverge through random edit sessions (inserts, deletes, replacements,
//! new and removed files, so conflicts happen too), then rebuilds the
//! union of every clone's changes in many orders: arbitrary orders through
//! `State::add_unchecked` and random dependency-respecting orders through
//! `State::add`. Every order must validate and give byte-identical
//! checkpoints and identical materialized trees. Finally the clones push
//! to one origin in a random order and a fresh clone must see that state,
//! and a checkpoint of the state must restore it exactly.

use oxy_core::objects::Change;
use oxy_core::repo::Repo;
use oxy_core::state::State;
use proptest::prelude::*;
use rand::rngs::StdRng;
use rand::seq::SliceRandom;
use rand::{Rng, SeedableRng};
use std::collections::{BTreeMap, BTreeSet};
use std::path::Path;

/// Point `$OXY_HOME` at a throwaway directory once per test process.
fn hermetic() {
    static ONCE: std::sync::Once = std::sync::Once::new();
    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();
    ONCE.call_once(|| {
        let d = tempfile::tempdir().unwrap();
        std::env::set_var("OXY_HOME", d.path());
        DIR.set(d).ok();
    });
}

/// Files the edits address; the first `SEEDED` exist in the base state.
const FILES: [&str; 4] = ["a.txt", "b.txt", "dir/c.txt", "d.txt"];
const SEEDED: usize = 3;

/// A few short lines, so identical lines are common and the diff has
/// to choose between equally good alignments.
const WORDS: [&str; 5] = ["alpha\n", "beta\n", "gamma\n", "delta\n", "alpha\n"];

#[derive(Clone, Debug)]
enum Edit {
    Insert { file: usize, at: usize, word: usize },
    Delete { file: usize, at: usize },
    Replace { file: usize, at: usize, word: usize },
    Remove { file: usize },
}

fn edit() -> impl Strategy<Value = Edit> {
    let file = 0..FILES.len();
    prop_oneof![
        4 => (file.clone(), any::<usize>(), 0..WORDS.len()).prop_map(|(file, at, word)| Edit::Insert { file, at, word }),
        3 => (file.clone(), any::<usize>()).prop_map(|(file, at)| Edit::Delete { file, at }),
        3 => (file.clone(), any::<usize>(), 0..WORDS.len()).prop_map(|(file, at, word)| Edit::Replace { file, at, word }),
        1 => file.prop_map(|file| Edit::Remove { file }),
    ]
}

/// One clone's session: a few commits of a few edits each.
fn session() -> impl Strategy<Value = Vec<Vec<Edit>>> {
    prop::collection::vec(prop::collection::vec(edit(), 1..5), 1..4)
}

fn lines(root: &Path, rel: &str) -> Option<Vec<String>> {
    let text = std::fs::read_to_string(root.join(rel)).ok()?;
    Some(text.split_inclusive('\n').map(String::from).collect())
}

fn apply(root: &Path, e: &Edit) {
    let file = match e {
        Edit::Remove { file } => {
            let _ = std::fs::remove_file(root.join(FILES[*file]));
            return;
        }
        Edit::Insert { file, .. } | Edit::Delete { file, .. } | Edit::Replace { file, .. } => *file,
    };
    let mut l = lines(root, FILES[file]).unwrap_or_default();
    match *e {
        Edit::Insert { at, word, .. } => l.insert(at % (l.len() + 1), WORDS[word].to_string()),
        Edit::Delete { at, .. } if !l.is_empty() => {
            let i = at % l.len();
            l.remove(i);
        }
        Edit::Replace { at, word, .. } if !l.is_empty() => {
            let i = at % l.len();
            l[i] = WORDS[word].to_string();
        }
        _ => {}
    }
    let path = root.join(FILES[file]);
    std::fs::create_dir_all(path.parent().unwrap()).unwrap();
    std::fs::write(path, l.concat()).unwrap();
}

/// Every change reachable from `repo`'s bookmark heads.
fn changes_of(repo: &Repo, into: &mut BTreeMap<oxy_core::hash::ChangeHash, Change>) {
    let mut stack = repo.bookmark_heads().unwrap();
    while let Some(h) = stack.pop() {
        if into.contains_key(&h) {
            continue;
        }
        let c = repo.store().get_change(&h).unwrap();
        stack.extend(c.deps.iter().copied());
        into.insert(h, c);
    }
}

/// What must not depend on order: the checkpoint bytes, the heads and
/// the materialized tree.
fn fingerprint(
    state: &State,
) -> (
    Vec<u8>,
    BTreeSet<oxy_core::hash::ChangeHash>,
    oxy_core::tree::TreeView,
    BTreeMap<String, oxy_core::state::FileState>,
) {
    let snap = state.materialize();
    (
        state.checkpoint_payload(),
        state.heads().into_iter().collect(),
        snap.tree,
        snap.files,
    )
}

fn run_case(sessions: Vec<Vec<Vec<Edit>>>, seed: u64) -> Result<(), TestCaseError> {
    hermetic();
    let dir = tempfile::tempdir().unwrap();
    let root = dir.path();
    let origin_path = root.join("origin");
    Repo::init(&origin_path).unwrap();
    let url = origin_path.to_string_lossy().to_string();

    // The shared base.
    let seed_repo = Repo::clone(&url, &root.join("seed")).unwrap();
    for (i, f) in FILES.iter().take(SEEDED).enumerate() {
        let p = root.join("seed").join(f);
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
        std::fs::write(p, WORDS[..=i + 1].concat()).unwrap();
    }
    seed_repo.commit("base", &[]).unwrap();
    assert!(seed_repo
        .push("origin", false)
        .unwrap()
        .iter()
        .all(|r| r.ok));

    // Diverge.
    let mut clones = Vec::new();
    for (n, session) in sessions.iter().enumerate() {
        let wc = root.join(format!("clone{n}"));
        let repo = Repo::clone(&url, &wc).unwrap();
        for (k, commit) in session.iter().enumerate() {
            for e in commit {
                apply(&wc, e);
            }
            let s = repo.snapshot("oxy status").unwrap();
            if s.statuses.is_empty() {
                continue;
            }
            repo.commit(&format!("clone {n} commit {k}"), &[]).unwrap();
        }
        clones.push(repo);
    }

    let mut all = BTreeMap::new();
    for c in &clones {
        changes_of(c, &mut all);
    }
    let changes: Vec<Change> = all.values().cloned().collect();

    // The reference: every change, sorted by hash.
    let mut reference = State::new();
    for c in &changes {
        reference.add_unchecked(c.clone());
    }
    prop_assert!(reference.validate().is_ok());
    let want = fingerprint(&reference);
    // A checkpoint restores the same state.
    let restored = State::from_checkpoint_payload(&want.0).unwrap();
    prop_assert!(
        fingerprint(&restored) == want,
        "checkpoint round trip changed the state"
    );

    let mut rng = StdRng::seed_from_u64(seed);
    for _ in 0..4 {
        // Any order at all.
        let mut order = changes.clone();
        order.shuffle(&mut rng);
        let mut st = State::new();
        for c in order {
            st.add_unchecked(c);
        }
        prop_assert!(st.validate().is_ok());
        prop_assert!(
            fingerprint(&st) == want,
            "unchecked order changed the state"
        );

        // A random order that respects dependencies, the order a fetch sees.
        let mut pending: Vec<&Change> = changes.iter().collect();
        let mut st = State::new();
        while !pending.is_empty() {
            let ready: Vec<usize> = (0..pending.len())
                .filter(|&i| pending[i].deps.iter().all(|d| st.contains(d)))
                .collect();
            prop_assert!(!ready.is_empty(), "dependency cycle");
            let pick = ready[rng.gen_range(0..ready.len())];
            st.add(pending.swap_remove(pick).clone()).unwrap();
        }
        prop_assert!(
            fingerprint(&st) == want,
            "dependency order changed the state"
        );
    }

    // Through the protocol: push in a random order, then a fresh clone.
    let mut order: Vec<usize> = (0..clones.len()).collect();
    order.shuffle(&mut rng);
    for i in order {
        let c = &clones[i];
        // A clone behind the origin is told to pull first, as a user is.
        if !c
            .push("origin", false)
            .is_ok_and(|r| r.iter().all(|r| r.ok))
        {
            c.pull("origin").unwrap();
            prop_assert!(
                c.push("origin", false).unwrap().iter().all(|r| r.ok),
                "push after pull"
            );
        }
    }
    let fresh = Repo::clone(&url, &root.join("fresh")).unwrap();
    let heads = fresh.bookmark_heads().unwrap();
    let pushed = fresh.load_state_full(&heads).unwrap();
    prop_assert!(fingerprint(&pushed) == want, "the pushed state differs");
    Ok(())
}

proptest! {
    #![proptest_config(ProptestConfig { cases: 32, ..ProptestConfig::default() })]

    #[test]
    fn order_of_changes_is_irrelevant(sessions in prop::collection::vec(session(), 2..4), seed in any::<u64>()) {
        run_case(sessions, seed)?;
    }
}