//! A repository on disk: the `.oxy` directory, one workspace, the operation

//! log, and the working-copy change (spec §12, §13.1).

//!

//! Not yet implemented from the spec: signatures and identities (the author

//! is `ObjectRef::ZERO`), packs, content-defined chunking (blobs use fixed

//! 256 KiB chunks), checkpoints, multiple workspaces, remotes, and resolving

//! conflicts by editing markers.

use crate::diff::{ranges, split_lines, text_edits};

use crate::hash::{hash_object, ChangeHash, ObjectRef, ObjectType};

use crate::ids::{ChangeId, NodeId, WorkspaceId};

use crate::objects::{Blob, Change, ChangeKind, Edit, Hlc, Mode, NodeKind, OpRef, TreeOp};

use crate::oplog::{Op, View, SNAPSHOT_SUFFIX};

use crate::state::{FileContent, Snapshot, State};

use crate::store::{Store, StoreError};

use crate::tree::OpKey;

use std::collections::{BTreeMap, BTreeSet, HashMap};

use std::fs;

use std::io::Write;

use std::path::{Path, PathBuf};

pub const OXY_DIR: &str = ".oxy";

pub const FORMAT_LINE: &str = "oxy repository format 1\n";

pub const CHUNK_SIZE: usize = 256 * 1024;

const BINARY_SNIFF: usize = 8 * 1024;

#[derive(Debug, thiserror::Error)]

pub enum RepoError {

    #[error("io: {0}")]

    Io(#[from] std::io::Error),

    #[error(transparent)]

    Store(#[from] StoreError),

    #[error(transparent)]

    Object(#[from] crate::objects::ObjectError),

    #[error(transparent)]

    State(#[from] crate::state::StateError),

    #[error("{0}")]

    Msg(String),

}

pub type Result<T> = std::result::Result<T, RepoError>;

fn fail<T>(s: impl Into<String>) -> Result<T> {

    Err(RepoError::Msg(s.into()))

}

/// Repository-local settings (`.oxy/config`, `key = value` lines).

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Config {

    pub author_name: String,

    pub author_email: String,

    pub bookmark: String,

}

impl Config {

    fn default_for_user() -> Config {

        let user = std::env::var("USER").unwrap_or_else(|_| "unknown".into());

        Config {

            author_name: std::env::var("OXY_AUTHOR_NAME").unwrap_or_else(|_| user.clone()),

            author_email: std::env::var("OXY_AUTHOR_EMAIL").unwrap_or_else(|_| format!("{user}@localhost")),

            bookmark: "main".into(),

        }

    }

    fn load(path: &Path) -> Result<Config> {

        let mut c = Config::default_for_user();

        for line in fs::read_to_string(path)?.lines() {

            let line = line.trim();

            if line.is_empty() || line.starts_with('#') {

                continue;

            }

            let Some((k, v)) = line.split_once('=') else { continue };

            let v = v.trim().trim_matches('"').to_string();

            match k.trim() {

                "author.name" => c.author_name = v,

                "author.email" => c.author_email = v,

                "workspace.bookmark" => c.bookmark = v,

                _ => {}

            }

        }

        Ok(c)

    }

    fn save(&self, path: &Path) -> Result<()> {

        let text = format!(

            "author.name = \"{}\"\nauthor.email = \"{}\"\nworkspace.bookmark = \"{}\"\n",

            self.author_name, self.author_email, self.bookmark

        );

        write_atomic(path, text.as_bytes())

    }

}

fn write_atomic(path: &Path, data: &[u8]) -> Result<()> {

    let tmp = path.with_extension("tmp");

    {

        let mut f = fs::File::create(&tmp)?;

        f.write_all(data)?;

        f.sync_all()?;

    }

    fs::rename(&tmp, path)?;

    Ok(())

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum ChangeStatus {

    Added,

    Modified,

    Removed,

    ModeChanged,

    /// The file is conflicted in the base state and was edited in the working copy.

    ConflictEdited,

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct PathStatus {

    pub path: String,

    pub status: ChangeStatus,

}

/// Result of snapshotting the working copy.

pub struct SnapshotResult {

    pub wc_hash: ChangeHash,

    pub wc: Change,

    /// The base state (closure of the working-copy change's dependencies).

    pub base: State,

    pub base_snapshot: Snapshot,

    pub statuses: Vec<PathStatus>,

    /// Whether the snapshot rewrote the working-copy change.

    pub changed: bool,

}

pub struct LogEntry {

    pub hash: ChangeHash,

    pub change: Change,

    pub is_working_copy: bool,

    pub is_head: bool,

}

struct FsEntry {

    kind: NodeKind,

    exec: bool,

    content: Vec<u8>,

}

pub struct Repo {

    root: PathBuf,

    oxy: PathBuf,

    store: Store,

    workspace: WorkspaceId,

    pub config: Config,

}

pub fn is_binary(content: &[u8]) -> bool {

    content[..content.len().min(BINARY_SNIFF)].contains(&0)

}

impl Repo {

    // ------------------------------------------------------------ lifecycle

    pub fn init(root: &Path) -> Result<Repo> {

        let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());

        let oxy = root.join(OXY_DIR);

        if oxy.exists() {

            return fail(format!("{} is already an oxy repository", root.display()));

        }

        fs::create_dir_all(oxy.join("ops"))?;

        write_atomic(&oxy.join("format"), FORMAT_LINE.as_bytes())?;

        let config = Config::default_for_user();

        config.save(&oxy.join("config"))?;

        let workspace = WorkspaceId::random();

        write_atomic(&oxy.join("workspace"), workspace.to_hex().as_bytes())?;

        let store = Store::open(oxy.join("objects"))?;

        let repo = Repo { root, oxy, store, workspace, config };

        let wc = repo.new_working_copy(vec![], "");

        let wc_hash = repo.store.put_change(&wc)?;

        let mut view = View::default();

        view.bookmarks.insert(repo.config.bookmark.clone(), vec![]);

        view.workspaces.insert(workspace, wc_hash);

        repo.record_op(&[], "oxy init", view)?;

        Ok(repo)

    }

    /// Open the repository containing `start` (searching upwards).

    pub fn open(start: &Path) -> Result<Repo> {

        let start = start.canonicalize()?;

        let mut dir: Option<&Path> = Some(&start);

        while let Some(d) = dir {

            let oxy = d.join(OXY_DIR);

            if oxy.is_dir() {

                let format = fs::read_to_string(oxy.join("format"))?;

                if format != FORMAT_LINE {

                    return fail(format!("unsupported repository format: {}", format.trim()));

                }

                let config = Config::load(&oxy.join("config"))?;

                let workspace = WorkspaceId::from_hex(fs::read_to_string(oxy.join("workspace"))?.trim())

                    .ok_or_else(|| RepoError::Msg("corrupt .oxy/workspace".into()))?;

                let store = Store::open(oxy.join("objects"))?;

                return Ok(Repo { root: d.to_path_buf(), oxy, store, workspace, config });

            }

            dir = d.parent();

        }

        fail(format!("no oxy repository found at or above {}", start.display()))

    }

    pub fn root(&self) -> &Path {

        &self.root

    }

    pub fn store(&self) -> &Store {

        &self.store

    }

    pub fn workspace(&self) -> WorkspaceId {

        self.workspace

    }

    fn new_working_copy(&self, deps: Vec<ChangeHash>, message: &str) -> Change {

        let mut c = Change {

            change_id: ChangeId::random(),

            deps,

            author: ObjectRef::ZERO,

            hlc: Hlc::now(),

            message: message.into(),

            tree_ops: vec![],

            edits: vec![],

            kind: ChangeKind::WorkingCopy,

        };

        c.normalize();

        c

    }

    // ------------------------------------------------------------ operation log

    pub fn head_op(&self) -> Result<(ObjectRef, Op)> {

        let hex = fs::read_to_string(self.oxy.join("ops").join("head"))?;

        let r = ObjectRef::from_hex(hex.trim()).ok_or_else(|| RepoError::Msg("corrupt .oxy/ops/head".into()))?;

        let op = Op::decode(&self.store.get_typed(&r, ObjectType::Op)?)?;

        Ok((r, op))

    }

    pub fn view(&self) -> Result<View> {

        Ok(self.head_op()?.1.view)

    }

    fn record_op(&self, parents: &[ObjectRef], command: &str, view: View) -> Result<ObjectRef> {

        let op = Op { parents: parents.to_vec(), hlc: Hlc::now(), command: command.into(), view };

        let r = self.store.put(ObjectType::Op, &op.encode())?;

        write_atomic(&self.oxy.join("ops").join("head"), r.to_hex().as_bytes())?;

        Ok(r)

    }

    pub fn op_log(&self) -> Result<Vec<(ObjectRef, Op)>> {

        let mut out = Vec::new();

        let (mut r, mut op) = self.head_op()?;

        loop {

            let next = op.parents.first().copied();

            out.push((r, op));

            match next {

                Some(p) => {

                    r = p;

                    op = Op::decode(&self.store.get_typed(&r, ObjectType::Op)?)?;

                }

                None => break,

            }

        }

        Ok(out)

    }

    /// Undo the last user command (spec §12.1). Operations that only recorded

    /// a working-copy snapshot are skipped, since the files are still on disk

    /// and the next snapshot recreates them.

    pub fn undo(&self) -> Result<Op> {

        let (_, mut op) = self.head_op()?;

        while op.is_snapshot() {

            let Some(parent) = op.parents.first() else { break };

            op = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?;

        }

        let Some(parent) = op.parents.first() else {

            return fail("nothing to undo");

        };

        let parent_op = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?;

        write_atomic(&self.oxy.join("ops").join("head"), parent.to_hex().as_bytes())?;

        Ok(parent_op)

    }

    /// The last operation that was not a snapshot.

    pub fn last_command(&self) -> Result<Op> {

        let (_, mut op) = self.head_op()?;

        while op.is_snapshot() {

            let Some(parent) = op.parents.first() else { break };

            op = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?;

        }

        Ok(op)

    }

    // ------------------------------------------------------------ states

    /// Load the dependency closure of `heads` from the store.

    pub fn load_state(&self, heads: &[ChangeHash]) -> Result<State> {

        let mut state = State::new();

        let mut stack: Vec<ChangeHash> = heads.to_vec();

        let mut seen: BTreeSet<ChangeHash> = BTreeSet::new();

        while let Some(h) = stack.pop() {

            if !seen.insert(h) {

                continue;

            }

            let c = self.store.get_change(&h)?;

            stack.extend(c.deps.iter().copied());

            state.add_unchecked(c);

        }

        state.validate()?;

        Ok(state)

    }

    pub fn working_copy(&self) -> Result<(ChangeHash, Change)> {

        let view = self.view()?;

        let h = *view

            .workspaces

            .get(&self.workspace)

            .ok_or_else(|| RepoError::Msg("this workspace is not in the current view".into()))?;

        Ok((h, self.store.get_change(&h)?))

    }

    pub fn bookmark_heads(&self) -> Result<Vec<ChangeHash>> {

        Ok(self.view()?.bookmarks.get(&self.config.bookmark).cloned().unwrap_or_default())

    }

    // ------------------------------------------------------------ blobs

    fn blob_for(content: &[u8]) -> Blob {

        Blob {

            length: content.len() as u64,

            chunks: content.chunks(CHUNK_SIZE).map(|c| hash_object(ObjectType::Chunk, c)).collect(),

        }

    }

    pub fn blob_ref(content: &[u8]) -> ObjectRef {

        Self::blob_for(content).hash()

    }

    pub fn store_blob(&self, content: &[u8]) -> Result<ObjectRef> {

        for c in content.chunks(CHUNK_SIZE) {

            self.store.put_chunk(c)?;

        }

        Ok(self.store.put(ObjectType::Blob, &Self::blob_for(content).encode())?)

    }

    pub fn read_blob(&self, r: &ObjectRef) -> Result<Vec<u8>> {

        let blob = Blob::decode(&self.store.get_typed(r, ObjectType::Blob)?)?;

        let mut out = Vec::with_capacity(blob.length as usize);

        for c in &blob.chunks {

            out.extend(self.store.get_typed(c, ObjectType::Chunk)?);

        }

        Ok(out)

    }

    // ------------------------------------------------------------ working copy

    fn walk_working_copy(&self) -> Result<BTreeMap<String, FsEntry>> {

        let mut wb = ignore::WalkBuilder::new(&self.root);

        wb.hidden(false)

            .git_ignore(false)

            .git_global(false)

            .git_exclude(false)

            .require_git(false)

            .follow_links(false)

            .add_custom_ignore_filename(".oxyignore");

        wb.filter_entry(|e| e.file_name() != OXY_DIR);

        let mut out = BTreeMap::new();

        for entry in wb.build() {

            let entry = entry.map_err(|e| RepoError::Msg(e.to_string()))?;

            let path = entry.path();

            if path == self.root {

                continue;

            }

            let rel = path.strip_prefix(&self.root).unwrap();

            let rel: String = rel.components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect::<Vec<_>>().join("/");

            let Some(ft) = entry.file_type() else { continue };

            if ft.is_dir() {

                continue;

            }

            if ft.is_symlink() {

                let target = fs::read_link(path)?;

                out.insert(rel, FsEntry { kind: NodeKind::Symlink, exec: false, content: target.to_string_lossy().as_bytes().to_vec() });

            } else if ft.is_file() {

                let exec = is_executable(&entry.metadata().map_err(|e| RepoError::Msg(e.to_string()))?);

                out.insert(rel, FsEntry { kind: NodeKind::File, exec, content: fs::read(path)? });

            }

        }

        Ok(out)

    }

    /// Snapshot the working copy into the working-copy change (spec §12.3).

    pub fn snapshot(&self, command: &str) -> Result<SnapshotResult> {

        let (op_ref, op) = self.head_op()?;

        let (old_hash, old_wc) = self.working_copy()?;

        let base = self.load_state(&old_wc.deps)?;

        let base_snapshot = base.materialize();

        let fs_entries = self.walk_working_copy()?;

        // Reuse the NodeIds the previous working-copy version assigned to new

        // paths, so an unchanged working copy hashes identically (spec §12.3).

        let reuse = added_node_paths(&old_wc, &base_snapshot);

        let mut b = ChangeBuilder::new(&base, &base_snapshot, reuse);

        for (path, fs_entry) in &fs_entries {

            match base_snapshot.files.get(path) {

                None => b.add_path(self, path, fs_entry)?,

                Some(expected) => b.update_path(self, path, fs_entry, expected)?,

            }

        }

        for (path, expected) in &base_snapshot.files {

            if fs_entries.contains_key(path) {

                continue;

            }

            let still_needed = expected.kind == NodeKind::Dir && fs_entries.keys().any(|p| p.starts_with(&format!("{path}/")));

            if !still_needed {

                b.remove_path(path, expected);

            }

        }

        let mut wc = Change {

            change_id: old_wc.change_id,

            deps: vec![],

            author: ObjectRef::ZERO,

            hlc: old_wc.hlc,

            message: old_wc.message.clone(),

            tree_ops: b.tree_ops,

            edits: b.edits,

            kind: ChangeKind::WorkingCopy,

        };

        let base_heads = base.maximal(&old_wc.deps);

        let mut deps: BTreeSet<ChangeHash> = base_heads.into_iter().collect();

        deps.extend(referenced_changes(&wc, &base));

        wc.deps = deps.into_iter().collect();

        wc.normalize();

        let mut statuses = b.statuses;

        statuses.sort_by(|a, b| a.path.cmp(&b.path));

        // Empty snapshot: hash the candidate before storing; only record an op on change.

        let new_hash = wc.hash();

        let changed = new_hash != old_hash;

        if changed {

            self.store.put_change(&wc)?;

            let mut view = op.view.clone();

            view.workspaces.insert(self.workspace, new_hash);

            self.record_op(&[op_ref], &format!("{command}{SNAPSHOT_SUFFIX}"), view)?;

        }

        Ok(SnapshotResult { wc_hash: new_hash, wc, base, base_snapshot, statuses, changed })

    }

    /// Turn the working-copy change into a normal change on the bookmark (spec §12.3).

    pub fn commit(&self, message: &str, extra_deps: &[ChangeHash]) -> Result<ChangeHash> {

        let snap = self.snapshot("oxy commit")?;

        if snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty() {

            return fail("nothing to commit: the working copy matches its base");

        }

        if snap.statuses.iter().any(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail("a conflicted file was edited; resolving conflicts is not implemented yet");

        }

        if message.trim().is_empty() {