//! The conflict resolver (hub spec §6.10): a conflicted text file of a

//! bookmark, region by region. For each region the user keeps one side,

//! every side in order, none, or text of their own; the file is put back

//! together around the unconflicted lines and committed through the

//! web-edit path, which makes it a `resolution` change depending on every

//! change that contributed to the conflict.

use super::edit::{after_web_commit, signer_for};

use super::settings::{csrf, require};

use super::{lookup_role, Error, Page, RepoShell, Shell};

use crate::auth::{Access, Viewer};

use crate::repos::edits;

use crate::repos::view::{self, FileBody};

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, State};

use axum::response::{IntoResponse, Redirect, Response};

use oxy_core::repo::FileEdit;

use std::collections::HashMap;

/// "Resolve in VS Code": the link oxygen-vscode handles (its README).

pub fn vscode_link(app: &Shared, owner: &str, name: &str, bookmark: &str, path: &str) -> String {

    use super::settings::urlencode;

    let url = format!("{}/{owner}/{name}", app.config.base_url().trim_end_matches('/'));

    format!("vscode://oxygenhub.oxygen/resolve?url={}&bookmark={}&path={}", urlencode(&url), urlencode(bookmark), urlencode(path))

}

/// A piece of a file rendered with `oxy` conflict markers (spec §9.5).

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

pub enum Piece {

    /// Lines outside any conflict, kept as they are.

    Plain(String),

    Region(Region),

}

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

pub struct Region {

    /// 1-based, as the markers number it.

    pub n: usize,

    pub sides: Vec<Side>,

}

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

pub struct Side {

    /// "change 3f2a…", or "deleted by change …".

    pub label: String,

    /// The side's lines, each ending in `\n`.

    pub text: String,

    /// A deletion side: `text` is what was deleted, shown for context;

    /// keeping this side keeps the deletion, so it contributes nothing.

    pub deletion: bool,

}

impl Side {

    /// What keeping this side puts in the file.

    pub fn kept(&self) -> &str {

        if self.deletion {

            ""

        } else {

            &self.text

        }

    }

}

impl Region {

    /// Every side in order: what keeping all of them puts in the file.

    pub fn all(&self) -> String {

        self.sides.iter().map(Side::kept).collect()

    }

}

/// Split a marked rendering into plain text and regions. `None` when the

/// markers are malformed (the page then offers the plain editor).

pub fn parse(marked: &str) -> Option<Vec<Piece>> {

    let mut out = Vec::new();

    let mut plain = String::new();

    let mut region: Option<Region> = None;

    let mut lines = marked.split_inclusive('\n').peekable();

    while let Some(line) = lines.next() {

        let bare = line.trim_end_matches('\n');

        if let Some(rest) = bare.strip_prefix("<<<<<<< oxy conflict ") {

            if region.is_some() {

                return None;

            }

            if !plain.is_empty() {

                out.push(Piece::Plain(std::mem::take(&mut plain)));

            }

            let (n, label) = header(rest)?;

            let mut side = Side { label, text: String::new(), deletion: false };

            if lines.peek().map(|l| l.trim_end_matches('\n')) == Some("-------") {

                lines.next();

                side.deletion = true;

            }

            region = Some(Region { n, sides: vec![side] });

        } else if let Some(rest) = bare.strip_prefix("======= oxy conflict ") {

            let r = region.as_mut()?;

            let (n, label) = header(rest)?;

            if n != r.n {

                return None;

            }

            r.sides.push(Side { label, text: String::new(), deletion: false });

        } else if bare.starts_with(">>>>>>> oxy conflict ") {

            out.push(Piece::Region(region.take()?));

        } else {

            match region.as_mut() {

                Some(r) => r.sides.last_mut()?.text.push_str(line),

                None => plain.push_str(line),

            }

        }

    }

    if region.is_some() {

        return None;

    }

    if !plain.is_empty() {

        out.push(Piece::Plain(plain));

    }

    Some(out)

}

/// `N of T, side I of K: LABEL` → (N, LABEL).

fn header(rest: &str) -> Option<(usize, String)> {

    let (n, tail) = rest.split_once(" of ")?;

    let label = tail.split_once(": ").map(|(_, l)| l.to_string()).unwrap_or_default();

    Some((n.trim().parse().ok()?, label))

}

/// A user's choice for one region.

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

pub enum Choice {

    Side(usize),

    All,

    None,

    Text(String),

}

/// The file with each region replaced by what was chosen for it; every

/// region needs a choice.

pub fn assemble(pieces: &[Piece], choices: &HashMap<usize, Choice>) -> Result<String, String> {

    let mut out = String::new();

    for p in pieces {

        match p {

            Piece::Plain(t) => out.push_str(t),

            Piece::Region(r) => match choices.get(&r.n) {

                Some(Choice::Side(i)) => {

                    out.push_str(r.sides.get(i.wrapping_sub(1)).ok_or_else(|| format!("conflict {} has no side {i}", r.n))?.kept())

                }

                Some(Choice::All) => out.push_str(&r.all()),

                Some(Choice::None) => {}

                Some(Choice::Text(t)) => {

                    let t = t.replace("\r\n", "\n");

                    out.push_str(&t);

                    if !t.is_empty() && !t.ends_with('\n') {

                        out.push('\n');

                    }

                }

                None => return Err(format!("choose how to resolve conflict {}", r.n)),

            },

        }

    }

    Ok(out)

}

/// One of the entries a name conflict shows at `NAME.oxy-conflict-N`.

#[derive(Clone, Debug)]

pub struct Candidate {

    pub path: String,

    pub content: Vec<u8>,

    /// The start of a text candidate, for the page.

    pub preview: Option<String>,

}

/// The candidates of a name conflict at `path` in a loaded state: the

/// files the tree shows as `path.oxy-conflict-N`. `None` when `path` has no

/// name conflict; an error for one between directories or links.

fn name_candidates(r: &oxy_core::repo::Repo, snapshot: &oxy_core::state::Snapshot, path: &str) -> Result<Option<Vec<Candidate>>, String> {

    use oxy_core::objects::NodeKind;

    use oxy_core::state::FileContent;

    use oxy_core::tree::TreeConflict;

    let by_node = snapshot.tree.by_node();

    for c in &snapshot.tree.conflicts {

        let TreeConflict::Name { parent, name, nodes } = c else { continue };

        let full = if parent.is_root() {

            name.clone()

        } else {

            match by_node.get(parent) {

                Some(e) => format!("{}/{name}", e.path),

                None => continue,

            }

        };

        if full != path {

            continue;

        }

        let mut out = Vec::new();

        for n in nodes {

            let Some(e) = by_node.get(n) else { continue };

            let f = snapshot.files.get(&e.path).ok_or("a candidate is missing")?;

            if f.kind != NodeKind::File {

                return Err("This conflict is between directories or links; resolve it from a client.".into());

            }

            let content = match &f.content {

                FileContent::Text { bytes, .. } => bytes.clone(),

                FileContent::Opaque { blobs } => match blobs.first() {

                    Some(b) => r.read_blob(b).map_err(|e| e.to_string())?,

                    None => vec![],

                },

                FileContent::Dir => continue,

            };

            let preview = std::str::from_utf8(&content).ok().map(|t| t.lines().take(40).collect::<Vec<_>>().join("\n"));

            out.push(Candidate { path: e.path.clone(), content, preview });

        }

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

        return Ok(Some(out));

    }

    Ok(None)

}

/// The versions of a binary file with a replace conflict at `path`, each

/// labelled with the change that wrote it.

fn replace_candidates(

    r: &oxy_core::repo::Repo,

    state: &oxy_core::state::State,

    snapshot: &oxy_core::state::Snapshot,

    path: &str,

) -> Option<Vec<Candidate>> {

    use oxy_core::state::FileContent;

    let f = snapshot.files.get(path)?;

    let FileContent::Opaque { blobs } = &f.content else { return None };

    if blobs.len() < 2 || f.kind != oxy_core::objects::NodeKind::File {

        return None;

    }

    let writers = state.live_replaces(&f.node);

    let mut out = Vec::new();

    for (i, b) in blobs.iter().enumerate() {

        let content = r.read_blob(b).ok()?;

        let by = writers.iter().find(|(_, n)| n == b).map(|(h, _)| state.label(h)).unwrap_or_default();

        let preview = std::str::from_utf8(&content).ok().map(|t| t.lines().take(40).collect::<Vec<_>>().join("\n"));

        out.push(Candidate { path: format!("version {} from change {by}", i + 1), content, preview });

    }

    Some(out)

}

/// What resolving `path` on a bookmark means.

enum Target {

    /// A conflicted text file, rendered with markers.

    Lines(String),

    /// A name conflict: keep one candidate at `path`.

    Name(Vec<Candidate>),

    /// A replace conflict of a binary file: keep one of its versions.

    Replace(Vec<Candidate>),

}

#[derive(Template)]

#[template(path = "resolve_name.html")]

pub struct NamePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    path: String,

    state: String,

    candidates: Vec<Candidate>,

    /// Whether the candidates are versions of one file (a replace

    /// conflict) rather than files wanting one name.

    versions: bool,

    vscode: String,

    delegation: Option<String>,

    error: Option<String>,

    message: String,

}

#[derive(Template)]

#[template(path = "resolve.html")]

pub struct ResolvePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    path: String,

    state: String,

    pieces: Vec<Piece>,

    /// The link that hands this conflict to oxygen-vscode.

    vscode: String,

    delegation: Option<String>,

    error: Option<String>,

    message: String,

}

/// The bookmark's state and what resolving `path` there means.

async fn load(app: &Shared, shell: &Shell, repo: &crate::repos::RepoName, bookmark: &str, path: &str) -> Result<(String, Target), Error> {

    let limit = app.config.limits.render_limit.0;

    let (b, p) = (bookmark.to_string(), path.to_string());

    let found = app

        .repos

        .read(repo, move |r, cache| {

            let Some(st) = r.view()?.bookmarks.get(&b).copied() else { return Ok(None) };

            let heads = r.store().get_state(&st)?.heads;

            let loaded = cache.load(r, &heads)?;

            let names = name_candidates(r, &loaded.snapshot, &p);

            let versions = replace_candidates(r, &loaded.state, &loaded.snapshot, &p);

            let file = if names.as_ref().is_ok_and(|n| n.is_some()) {

                None

            } else {

                let target = view::resolve(r, cache, &b)?;

                Some(view::file(r, cache, target, &p, limit))

            };

            Ok(Some((st.to_hex(), names, file, versions)))

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let Some((state, names, file, versions)) = found else {

        return Err(Error::bad(shell.clone(), "Conflicts are resolved on a bookmark."));

    };

    if let Some(v) = versions {

        return Ok((state, Target::Replace(v)));

    }

    match names {

        Ok(Some(c)) => return Ok((state, Target::Name(c))),

        Err(msg) => return Err(Error::bad(shell.clone(), &msg)),

        Ok(None) => {}

    }

    let file = match file {

        Some(Ok(f)) => f,

        Some(Err(e)) => return Err(Error::from_repo(shell.clone(), e)),

        None => return Err(Error::bad(shell.clone(), "Nothing to resolve there.")),

    };

    match file.body {

        FileBody::Text(t) if file.conflicted => Ok((state, Target::Lines(t))),

        FileBody::Text(_) => Err(Error::bad(shell.clone(), "That file has no conflicts on this bookmark.")),

        _ => Err(Error::bad(shell.clone(), "Only text files within the render limit, and name conflicts, are resolved in the browser.")),

    }

}

#[allow(clippy::too_many_arguments)]

async fn page(

    app: &Shared,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    bookmark: &str,

    path: &str,

    error: Option<String>,

    message: Option<String>,

) -> Result<Page<ResolvePage>, Error> {

    let shell = Shell::new(app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), viewer);

    let me = require(viewer, &shell)?;

    let (repo, row, role) = lookup_role(app, &shell, viewer, owner, name, Access::Write).await?;

    let (state, target) = load(app, &shell, &repo, bookmark, path).await?;

    let text = match target {

        Target::Lines(t) => t,

        Target::Name(_) | Target::Replace(_) => return Err(Error::bad(shell, "That conflict is resolved by keeping a candidate.")),

    };

    let Some(pieces) = parse(&text) else {

        return Err(Error::bad(shell, "The conflict markers could not be read; resolve the file in the plain editor."));

    };

    let delegation = signer_for(app, me.account.id).await.err();

    Ok(Page(ResolvePage {

        shell,

        repo: RepoShell::new(app, &row, "conflicts").with_role(role),

        bookmark: bookmark.to_string(),

        path: path.to_string(),

        state,

        pieces,

        vscode: vscode_link(app, owner, name, bookmark, path),

        delegation,

        error,

        message: message.unwrap_or_else(|| format!("Resolve the conflicts in {path}")),

    }))

}

pub async fn form(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, bookmark, path)): Path<(String, String, String, String)>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), &viewer);

    let (repo, _, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    match load(&app, &shell, &repo, &bookmark, &path).await?.1 {

        // Malformed markers: the plain editor still resolves the file.

        Target::Lines(text) if parse(&text).is_none() => {

            Ok(Redirect::to(&format!("/{owner}/{name}/edit/{bookmark}/{path}")).into_response())

        }

        Target::Lines(_) => Ok(page(&app, &viewer, &owner, &name, &bookmark, &path, None, None).await?.into_response()),

        Target::Name(_) | Target::Replace(_) => {

            Ok(name_page(&app, &viewer, &owner, &name, &bookmark, &path, None, None).await?.into_response())

        }

    }

}

#[allow(clippy::too_many_arguments)]

async fn name_page(

    app: &Shared,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    bookmark: &str,

    path: &str,

    error: Option<String>,

    message: Option<String>,

) -> Result<Page<NamePage>, Error> {

    let shell = Shell::new(app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), viewer);

    let me = require(viewer, &shell)?;

    let (repo, row, role) = lookup_role(app, &shell, viewer, owner, name, Access::Write).await?;

    let (state, target) = load(app, &shell, &repo, bookmark, path).await?;

    let (candidates, versions) = match target {

        Target::Name(c) => (c, false),

        Target::Replace(c) => (c, true),

        Target::Lines(_) => return Err(Error::bad(shell, "That conflict is resolved region by region.")),

    };

    let delegation = signer_for(app, me.account.id).await.err();

    Ok(Page(NamePage {

        shell,

        repo: RepoShell::new(app, &row, "conflicts").with_role(role),

        bookmark: bookmark.to_string(),

        path: path.to_string(),

        state,

        candidates,

        versions,

        vscode: vscode_link(app, owner, name, bookmark, path),

        delegation,

        error,

        message: message.unwrap_or_else(|| {

            if versions {

                format!("Resolve the conflicting versions of {path}")

            } else {

                format!("Resolve the name conflict at {path}")

            }

        }),

    }))

}

pub async fn save(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, bookmark, path)): Path<(String, String, String, String)>,

    Form(f): Form<HashMap<String, String>>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, f.get("_csrf").map(String::as_str).unwrap_or(""), &shell)?;

    let (repo, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let message = f.get("message").map(|m| m.trim().to_string()).unwrap_or_default();

    let again = |msg: String| {

        let (app, viewer, owner, name, bookmark, path, message) =

            (app.clone(), viewer.clone(), owner.clone(), name.clone(), bookmark.clone(), path.clone(), message.clone());

        async move { page(&app, &viewer, &owner, &name, &bookmark, &path, Some(msg), Some(message)).await.map(IntoResponse::into_response) }

    };

    let (state, target) = load(&app, &shell, &repo, &bookmark, &path).await?;

    let stale = f.get("state") != Some(&state);

    let text = match target {

        Target::Lines(t) => t,

        Target::Name(candidates) | Target::Replace(candidates) if candidates.is_empty() => {

            return again("There are no candidates to keep.".into()).await;