//! 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;

/// 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)

}

#[derive(Template)]

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

pub struct ResolvePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    path: String,

    state: String,

    pieces: Vec<Piece>,

    delegation: Option<String>,

    error: Option<String>,

    message: String,

}

/// The bookmark's state, and the file rendered there when it is a

/// conflicted text file.

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

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

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

    let (state, file) = app

        .repos

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

            let state = r.view()?.bookmarks.get(&b).map(|s| s.to_hex());

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

            Ok((state, view::file(r, cache, target, &p, limit)?))

        })

        .await

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

    let Some(state) = state else { return Err(Error::bad(shell.clone(), "Conflicts are resolved on a bookmark.")) };

    match file.body {

        FileBody::Text(t) if file.conflicted => Ok((state, 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 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, text) = load(app, &shell, &repo, bookmark, path).await?;

    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,

        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> {

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

    let shell = Shell::new(&app, "", &viewer);

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

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

    if parse(&text).is_none() {

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

    }

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

}

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, text) = load(&app, &shell, &repo, &bookmark, &path).await?;

    if f.get("state") != Some(&state) {

        return again(format!("{bookmark} has moved since this page was loaded; the conflicts below are as they are now.")).await;

    }

    let Some(pieces) = parse(&text) else { return again("The conflict markers could not be read.".into()).await };

    let mut choices = HashMap::new();

    for p in &pieces {

        if let Piece::Region(r) = p {

            let choice = match f.get(&format!("r{}", r.n)).map(String::as_str) {

                Some("all") => Choice::All,

                Some("none") => Choice::None,

                Some("text") => Choice::Text(f.get(&format!("t{}", r.n)).cloned().unwrap_or_default()),

                Some(s) => match s.strip_prefix("side").and_then(|i| i.parse().ok()) {

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

                    None => continue,

                },

                None => continue,

            };

            choices.insert(r.n, choice);

        }

    }

    let content = match assemble(&pieces, &choices) {

        Ok(c) => c,

        Err(msg) => return again(msg).await,

    };

    if message.is_empty() {

        return again("Describe the resolution.".into()).await;

    }

    let signer = match signer_for(&app, me.account.id).await {

        Ok(s) => s,

        Err(msg) => return again(msg).await,

    };

    let edit = vec![FileEdit { path: path.clone(), content: Some(content.into_bytes()) }];

    let done = match edits::commit(&app.repos, &repo, bookmark.clone(), bookmark.clone(), edit, message.clone(), signer).await {

        Ok(d) => d,

        Err(e) => return again(e.to_string()).await,

    };

    after_web_commit(&app, &me.account, &row, &owner, &name, &done, &message).await;

    Ok(Redirect::to(&format!("/{owner}/{name}/change/{}", done.change.to_hex())).into_response())

}

#[cfg(test)]

mod tests {

    use super::*;

    const MARKED: &str = "a\n<<<<<<< oxy conflict 1 of 2, side 1 of 2: change 0202\nfrom-2\n======= oxy conflict 1 of 2, side 2 of 2: change 0303\nfrom-3\nmore-3\n>>>>>>> oxy conflict 1 of 2 end\nb\n<<<<<<< oxy conflict 2 of 2, side 1 of 2: deleted by change 0404\n-------\ngone\n======= oxy conflict 2 of 2, side 2 of 2: change 0505\nadded\n>>>>>>> oxy conflict 2 of 2 end\nc\n";

    #[test]

    fn markers_parse_into_regions_and_sides() {

        let p = parse(MARKED).unwrap();

        assert_eq!(p.len(), 5);

        assert_eq!(p[0], Piece::Plain("a\n".into()));

        let Piece::Region(r1) = &p[1] else { panic!() };

        assert_eq!((r1.n, r1.sides.len()), (1, 2));

        assert_eq!((r1.sides[0].label.as_str(), r1.sides[0].text.as_str()), ("change 0202", "from-2\n"));

        assert_eq!(r1.sides[1].text, "from-3\nmore-3\n");

        let Piece::Region(r2) = &p[3] else { panic!() };

        assert!(r2.sides[0].deletion && r2.sides[0].text == "gone\n" && r2.sides[0].kept().is_empty());

        assert_eq!(r2.sides[0].label, "deleted by change 0404");

        assert_eq!(p[4], Piece::Plain("c\n".into()));

        assert!(parse("<<<<<<< oxy conflict 1 of 1, side 1 of 2: change x\nno end\n").is_none());

        assert_eq!(parse("plain\n").unwrap(), vec![Piece::Plain("plain\n".into())]);

    }

    #[test]

    fn choices_assemble_the_file() {

        let p = parse(MARKED).unwrap();

        let pick = |a: Choice, b: Choice| assemble(&p, &HashMap::from([(1, a), (2, b)]));

        assert_eq!(pick(Choice::Side(2), Choice::Side(1)).unwrap(), "a\nfrom-3\nmore-3\nb\nc\n", "the deletion wins: nothing");

        assert_eq!(pick(Choice::All, Choice::Side(2)).unwrap(), "a\nfrom-2\nfrom-3\nmore-3\nb\nadded\nc\n");

        assert_eq!(pick(Choice::None, Choice::Text("mine".into())).unwrap(), "a\nb\nmine\nc\n", "own text ends its line");

        assert!(pick(Choice::Side(3), Choice::None).unwrap_err().contains("no side 3"));

        assert!(assemble(&p, &HashMap::from([(1, Choice::None)])).unwrap_err().contains("conflict 2"));

    }

}