//! Merge conflict resolution helpers.

use std::path::Path;
use std::process::Command;

pub(super) fn try_resolve_conflicts(worktree: &Path) -> Result<(bool, String), String> {
    let mut log = String::new();

    // List conflicted files.
    let ls = Command::new("git")
        .args(["diff", "--name-only", "--diff-filter=U"])
        .current_dir(worktree)
        .output()
        .map_err(|e| format!("Failed to list conflicted files: {e}"))?;

    let file_list = String::from_utf8_lossy(&ls.stdout);
    let conflicted_files: Vec<&str> = file_list.lines().filter(|l| !l.is_empty()).collect();

    if conflicted_files.is_empty() {
        log.push_str("No conflicted files found (conflict may be index-only).\n");
        return Ok((false, log));
    }

    log.push_str(&format!("Conflicted files ({}):\n", conflicted_files.len()));
    for f in &conflicted_files {
        log.push_str(&format!("  - {f}\n"));
    }

    // First pass: check that all files can be resolved before touching any.
    let mut resolutions: Vec<(&str, String)> = Vec::new();
    for file in &conflicted_files {
        let file_path = worktree.join(file);
        let content = std::fs::read_to_string(&file_path)
            .map_err(|e| format!("Failed to read conflicted file '{file}': {e}"))?;

        match resolve_simple_conflicts(&content) {
            Some(resolved) => {
                log.push_str(&format!("  [auto-resolve] {file}\n"));
                resolutions.push((file, resolved));
            }
            None => {
                log.push_str(&format!("  [COMPLEX — cannot auto-resolve] {file}\n"));
                return Ok((false, log));
            }
        }
    }

    // Second pass: write resolved content and stage.
    for (file, resolved) in &resolutions {
        let file_path = worktree.join(file);
        std::fs::write(&file_path, resolved)
            .map_err(|e| format!("Failed to write resolved file '{file}': {e}"))?;

        let add = Command::new("git")
            .args(["add", file])
            .current_dir(worktree)
            .output()
            .map_err(|e| format!("Failed to stage resolved file '{file}': {e}"))?;
        if !add.status.success() {
            return Err(format!(
                "git add failed for '{file}': {}",
                String::from_utf8_lossy(&add.stderr)
            ));
        }
    }

    Ok((true, log))
}

fn resolve_simple_conflicts(content: &str) -> Option<String> {
    // Quick check: if there are no conflict markers at all, nothing to do.
    if !content.contains("<<<<<<<") {
        return Some(content.to_string());
    }

    let mut result = String::new();
    let mut lines = content.lines().peekable();

    while let Some(line) = lines.next() {
        if line.starts_with("<<<<<<<") {
            // Collect the "ours" side (between <<<<<<< and =======).
            let mut ours = Vec::new();
            let mut found_separator = false;
            for next_line in lines.by_ref() {
                if next_line.starts_with("=======") {
                    found_separator = true;
                    break;
                }
                ours.push(next_line);
            }
            if !found_separator {
                return None; // Malformed conflict block.
            }

            // Collect the "theirs" side (between ======= and >>>>>>>).
            let mut theirs = Vec::new();
            let mut found_end = false;
            for next_line in lines.by_ref() {
                if next_line.starts_with(">>>>>>>") {
                    found_end = true;
                    break;
                }
                theirs.push(next_line);
            }
            if !found_end {
                return None; // Malformed conflict block.
            }

            // Both sides must be non-empty additions to be considered simple.
            // If either side is empty, it means one side deleted something — complex.
            if ours.is_empty() && theirs.is_empty() {
                // Both empty — nothing to add, skip.
                continue;
            }

            // Accept both: ours first, then theirs.
            for l in &ours {
                result.push_str(l);
                result.push('\n');
            }
            for l in &theirs {
                result.push_str(l);
                result.push('\n');
            }
        } else {
            result.push_str(line);
            result.push('\n');
        }
    }

    // Preserve trailing newline consistency: if original ended without
    // newline, strip the trailing one we added.
    if !content.ends_with('\n') && result.ends_with('\n') {
        result.pop();
    }

    Some(result)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolve_simple_conflicts_no_markers() {
        let input = "line 1\nline 2\nline 3\n";
        let result = resolve_simple_conflicts(input);
        assert_eq!(result, Some(input.to_string()));
    }

    #[test]
    fn resolve_simple_conflicts_additive() {
        let input = "\
before
<<<<<<< HEAD
ours line 1
ours line 2
=======
theirs line 1
theirs line 2
>>>>>>> feature
after
";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(
            !result.contains("<<<<<<<"),
            "should not contain conflict markers"
        );
        assert!(
            !result.contains(">>>>>>>"),
            "should not contain conflict markers"
        );
        assert!(result.contains("ours line 1"));
        assert!(result.contains("ours line 2"));
        assert!(result.contains("theirs line 1"));
        assert!(result.contains("theirs line 2"));
        assert!(result.contains("before"));
        assert!(result.contains("after"));
        // Ours comes before theirs
        let ours_pos = result.find("ours line 1").unwrap();
        let theirs_pos = result.find("theirs line 1").unwrap();
        assert!(ours_pos < theirs_pos, "ours should come before theirs");
    }

    #[test]
    fn resolve_simple_conflicts_multiple_blocks() {
        let input = "\
header
<<<<<<< HEAD
ours block 1
=======
theirs block 1
>>>>>>> feature
middle
<<<<<<< HEAD
ours block 2
=======
theirs block 2
>>>>>>> feature
footer
";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(!result.contains("<<<<<<<"));
        assert!(result.contains("ours block 1"));
        assert!(result.contains("theirs block 1"));
        assert!(result.contains("ours block 2"));
        assert!(result.contains("theirs block 2"));
        assert!(result.contains("header"));
        assert!(result.contains("middle"));
        assert!(result.contains("footer"));
    }

    #[test]
    fn resolve_simple_conflicts_malformed_no_separator() {
        let input = "\
<<<<<<< HEAD
ours
>>>>>>> feature
";
        let result = resolve_simple_conflicts(input);
        assert!(
            result.is_none(),
            "malformed conflict (no separator) should return None"
        );
    }

    #[test]
    fn resolve_simple_conflicts_malformed_no_end() {
        let input = "\
<<<<<<< HEAD
ours
=======
theirs
";
        let result = resolve_simple_conflicts(input);
        assert!(
            result.is_none(),
            "malformed conflict (no end marker) should return None"
        );
    }

    #[test]
    fn resolve_simple_conflicts_preserves_no_trailing_newline() {
        let input = "before\n<<<<<<< HEAD\nours\n=======\ntheirs\n>>>>>>> branch\nafter";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(
            !result.ends_with('\n'),
            "should not add trailing newline if original lacks one"
        );
        assert!(result.ends_with("after"));
    }

    #[test]
    fn resolve_simple_conflicts_real_markers_additive_both_sides() {
        // The most common real-world case: both branches add different content
        // (e.g. different functions) to the same region of a file.
        let input = "// shared code\n\
<<<<<<< HEAD\n\
fn master_fn() { println!(\"from master\"); }\n\
=======\n\
fn feature_fn() { println!(\"from feature\"); }\n\
>>>>>>> feature/story-42\n\
// end\n";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(!result.contains("<<<<<<<"), "no conflict markers in output");
        assert!(!result.contains(">>>>>>>"), "no conflict markers in output");
        assert!(!result.contains("======="), "no separator in output");
        assert!(
            result.contains("fn master_fn()"),
            "master (ours) side must be preserved"
        );
        assert!(
            result.contains("fn feature_fn()"),
            "feature (theirs) side must be preserved"
        );
        assert!(
            result.contains("// shared code"),
            "context before conflict preserved"
        );
        assert!(
            result.contains("// end"),
            "context after conflict preserved"
        );
        // ours (master) must appear before theirs (feature)
        assert!(
            result.find("master_fn").unwrap() < result.find("feature_fn").unwrap(),
            "master side must appear before feature side"
        );
    }

    #[test]
    fn resolve_simple_conflicts_real_markers_multiple_conflict_blocks() {
        // Two separate conflict blocks in the same file — as happens when two
        // feature branches both add imports AND test suites to the same file.
        let input = "// imports\n\
<<<<<<< HEAD\n\
import { A } from './a';\n\
=======\n\
import { B } from './b';\n\
>>>>>>> feature/story-43\n\
// implementation\n\
<<<<<<< HEAD\n\
export function masterImpl() {}\n\
=======\n\
export function featureImpl() {}\n\
>>>>>>> feature/story-43\n";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(!result.contains("<<<<<<<"), "no conflict markers in output");
        assert!(
            result.contains("import { A }"),
            "first block ours preserved"
        );
        assert!(
            result.contains("import { B }"),
            "first block theirs preserved"
        );
        assert!(result.contains("masterImpl"), "second block ours preserved");
        assert!(
            result.contains("featureImpl"),
            "second block theirs preserved"
        );
        assert!(
            result.contains("// imports"),
            "surrounding context preserved"
        );
        assert!(
            result.contains("// implementation"),
            "surrounding context preserved"
        );
    }

    #[test]
    fn resolve_simple_conflicts_real_markers_one_side_empty() {
        // Ours (master) has no content in the conflicted region; theirs (feature)
        // adds new content. Resolution: keep theirs.
        let input = "before\n\
<<<<<<< HEAD\n\
=======\n\
feature_addition\n\
>>>>>>> feature/story-44\n\
after\n";
        let result = resolve_simple_conflicts(input).unwrap();
        assert!(!result.contains("<<<<<<<"), "no conflict markers");
        assert!(
            result.contains("feature_addition"),
            "non-empty side preserved"
        );
        assert!(result.contains("before"), "context preserved");
        assert!(result.contains("after"), "context preserved");
    }
}