// Copyright (c) 2019-2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by a GPL license that can be found in the LICENSE file.
module main

import veb
import validation
import git
import time
import strings

struct PrWithUser {
    pr   PullRequest
    user User
}

struct PrCommentWithUser {
    item PrComment
    user User
}

struct PrReviewWithUser {
    review   PrReview
    user     User
    comments []PrReviewComment
}

struct PrTimelineEntry {
mut:
    kind       string // 'comment' or 'review'
    created_at int
    user       User
    comment    PrComment
    review     PrReview
    rcomments  []PrReviewCommentWithUser
}

struct PrReviewCommentWithUser {
    item PrReviewComment
    user User
}

struct PrFileTreeRow {
    path       string
    name       string
    depth      int
    indent_px  int
    is_dir     bool
    is_new     bool
    is_deleted bool
    is_renamed bool
    additions  int
    deletions  int
}

fn render_pr_file_tree(file_tree []PrFileTreeRow) veb.RawHtml {
    mut out := strings.new_builder(file_tree.len * 160)
    for row in file_tree {
        path := html_escape_text(row.path)
        name := html_escape_text(row.name)
        indent := row.indent_px
        if row.is_dir {
            out.write_string('<button type=button class="r d" q="${path}" style="--i:${indent}px" aria-expanded=true><b></b><span>${name}</span></button>')
        } else {
            status := row.status()
            out.write_string('<a class="r f" href="#diff-${path}" p="${path}" style="--i:${indent}px" title="${path}"><b></b><span>${name}</span><em>${status}</em><small><b>+${row.additions}</b><i>-${row.deletions}</i></small></a>')
        }
    }
    return veb.RawHtml(out.str())
}

fn (row PrFileTreeRow) status() string {
    if row.is_new {
        return 'A'
    }
    if row.is_deleted {
        return 'D'
    }
    if row.is_renamed {
        return 'R'
    }
    return 'M'
}

fn render_pr_file_diff(fd FileDiff, comments_by_key map[string][]PrReviewCommentWithUser, can_comment bool, lang Lang) veb.RawHtml {
    mut out := strings.new_builder(1024)
    path := html_escape_text(fd.path)
    out.write_string('<div class=pr-diff id="diff-${path}" data-diff-path="${path}"><div class=pr-diff__header><span class=pr-diff__path>')
    if fd.is_renamed && fd.old_path != fd.path {
        old_path := html_escape_text(fd.old_path)
        renamed_label := tr_text(lang, 'commit_file_renamed')
        out.write_string('<span class=pr-diff__tag>${renamed_label}</span><span class=pr-diff__oldpath>${old_path} →</span>')
    }
    out.write_string(path)
    if fd.is_new {
        new_label := tr_text(lang, 'commit_file_new')
        out.write_string('<span class="pr-diff__tag pr-diff__tag--new">${new_label}</span>')
    }
    if fd.is_deleted {
        deleted_label := tr_text(lang, 'commit_file_deleted')
        out.write_string('<span class="pr-diff__tag pr-diff__tag--deleted">${deleted_label}</span>')
    }
    out.write_string('</span><span class=pr-diff__counts><span class=pr-diff__add>+${fd.additions}</span><span class=pr-diff__del>-${fd.deletions}</span></span></div>')
    if fd.is_binary {
        binary_label := tr_text(lang, 'pr_binary_file')
        out.write_string('<div class=pr-diff__binary>${binary_label}</div>')
    } else {
        out.write_string(pr_diff_table_html(fd, comments_by_key, can_comment))
    }
    out.write_string('</div>')
    return veb.RawHtml(out.str())
}

fn tr_text(lang Lang, key string) string {
    return html_escape_text(veb.tr(lang.str(), key).trim_space())
}

fn build_pr_file_tree_rows(file_diffs []FileDiff) []PrFileTreeRow {
    mut sorted := file_diffs.clone()
    sorted.sort(a.path < b.path)
    mut rows := []PrFileTreeRow{}
    mut seen_dirs := map[string]bool{}
    for fd in sorted {
        parts := fd.path.split('/')
        if parts.len == 0 {
            continue
        }
        mut current_path := ''
        if parts.len > 1 {
            for idx := 0; idx < parts.len - 1; idx++ {
                part := parts[idx]
                if part == '' {
                    continue
                }
                current_path = if current_path == '' { part } else { '${current_path}/${part}' }
                if current_path !in seen_dirs {
                    seen_dirs[current_path] = true
                    rows << PrFileTreeRow{
                        path:      current_path
                        name:      part
                        depth:     idx
                        indent_px: 10 + idx * 16
                        is_dir:    true
                    }
                }
            }
        }
        rows << PrFileTreeRow{
            path:       fd.path
            name:       parts[parts.len - 1]
            depth:      parts.len - 1
            indent_px:  10 + (parts.len - 1) * 16
            is_new:     fd.is_new
            is_deleted: fd.is_deleted
            is_renamed: fd.is_renamed
            additions:  fd.additions
            deletions:  fd.deletions
        }
    }
    return rows
}

// GET /:username/:repo_name/pulls
@['/:username/:repo_name/pulls']
pub fn (mut app App) handle_get_repo_pulls(mut ctx Context, username string, repo_name string) veb.Result {
    return app.repo_pulls(mut ctx, username, repo_name, 'open')
}

@['/:username/:repo_name/pulls/:tab']
pub fn (mut app App) repo_pulls(mut ctx Context, username string, repo_name string, tab string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    if !app.has_user_repo_read_access(ctx, ctx.user.id, repo.id) && !repo.is_public {
        return ctx.not_found()
    }
    current_tab := if tab in ['open', 'closed', 'merged'] { tab } else { 'open' }
    status := match current_tab {
        'closed' { PrStatus.closed }
        'merged' { PrStatus.merged }
        else { PrStatus.open }
    }

    prs := app.find_repo_pull_requests(repo.id, status)
    mut prs_with_users := []PrWithUser{}
    for pr in prs {
        author := app.get_user_by_id(pr.author_id) or { continue }
        prs_with_users << PrWithUser{
            pr:   pr
            user: author
        }
    }
    _ := app.get_repo_open_pr_count(repo.id)
    tab_open_class := if current_tab == 'open' { 'pr-tab pr-tab--active' } else { 'pr-tab' }
    tab_merged_class := if current_tab == 'merged' { 'pr-tab pr-tab--active' } else { 'pr-tab' }
    tab_closed_class := if current_tab == 'closed' { 'pr-tab pr-tab--active' } else { 'pr-tab' }
    tab_title := match current_tab {
        'closed' { 'Closed pull requests' }
        'merged' { 'Merged pull requests' }
        else { 'Open pull requests' }
    }

    ctx.set_page_title([tab_title, '${repo.user_name}/${repo.name}'])
    return $veb.html('templates/pulls.html')
}

// GET /:username/:repo_name/pulls/new
@['/:username/:repo_name/compare']
pub fn (mut app App) new_pull_request_form(mut ctx Context, username string, repo_name string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    if !app.has_user_repo_read_access(ctx, ctx.user.id, repo.id) && !repo.is_public {
        return ctx.not_found()
    }
    branches := app.get_all_repo_branches(repo.id)
    base := if 'base' in ctx.query { ctx.query['base'] } else { repo.primary_branch }
    head := if 'head' in ctx.query { ctx.query['head'] } else { '' }
    mut commits := []Commit{}
    mut file_diffs := []FileDiff{}
    mut suggested_title := ''
    mut error_msg := ''
    mut has_compare := false
    if head != '' && head != base {
        has_compare = true
        if !app.contains_repo_branch(repo.id, head) || !app.contains_repo_branch(repo.id, base) {
            error_msg = 'Both base and compare branches must exist in this repository.'
            has_compare = false
        } else {
            commits = repo.list_commits_between(base, head)
            raw_diff := repo.diff_branches(base, head)
            file_diffs = parse_unified_diff(raw_diff)
            if commits.len > 0 {
                suggested_title = commits[0].message
            }
        }
    }
    ctx.set_page_title(['New pull request', '${repo.user_name}/${repo.name}'])
    return $veb.html('templates/new/pull.html')
}

// POST /:username/:repo_name/pulls
@['/:username/:repo_name/pulls'; post]
pub fn (mut app App) handle_create_pull_request(mut ctx Context, username string, repo_name string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    if !app.has_user_repo_read_access(ctx, ctx.user.id, repo.id) && !repo.is_public {
        return ctx.not_found()
    }
    title := ctx.form['title']
    description := ctx.form['description']
    head := ctx.form['head']
    base := ctx.form['base']
    if validation.is_string_empty(title) || validation.is_string_empty(head)
        || validation.is_string_empty(base) {
        ctx.error('Title, head and base branches are required')
        return ctx.redirect('/${username}/${repo_name}/compare?base=${base}&head=${head}')
    }
    if head == base {
        ctx.error('Head and base must differ')
        return ctx.redirect('/${username}/${repo_name}/compare')
    }
    if !app.contains_repo_branch(repo.id, head) || !app.contains_repo_branch(repo.id, base) {
        ctx.error('Branches not found')
        return ctx.redirect('/${username}/${repo_name}/compare')
    }
    commits := repo.list_commits_between(base, head)
    if commits.len == 0 {
        ctx.error('No commits between base and head')
        return ctx.redirect('/${username}/${repo_name}/compare?base=${base}&head=${head}')
    }
    pr_id := app.add_pull_request(repo.id, ctx.user.id, title, description, head, base) or {
        ctx.error('Could not create pull request')
        return ctx.redirect('/${username}/${repo_name}/compare')
    }
    app.increment_repo_open_prs(repo.id) or { app.info(err.str()) }
    app.dispatch_webhook(repo.id, 'pr', WebhookPrPayload{
        action: 'opened'
        repo:   '${username}/${repo_name}'
        number: pr_id
        title:  title
        author: ctx.user.username
        head:   head
        base:   base
    })
    return ctx.redirect('/${username}/${repo_name}/pull/${pr_id}')
}

// GET /:username/:repo_name/pull/:id
@['/:username/:repo_name/pull/:id']
pub fn (mut app App) pull_request(mut ctx Context, username string, repo_name string, id string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    if !app.has_user_repo_read_access(ctx, ctx.user.id, repo.id) && !repo.is_public {
        return ctx.not_found()
    }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    author := app.get_user_by_id(pr.author_id) or { return ctx.not_found() }
    commits := repo.list_commits_between(pr.base_branch, pr.head_branch)
    comments := app.get_pr_comments(pr.id)
    reviews := app.get_pr_reviews(pr.id)
    rcomments := app.get_pr_review_comments(pr.id)
    mut timeline := []PrTimelineEntry{}
    for c in comments {
        u := app.get_user_by_id(c.author_id) or { continue }
        timeline << PrTimelineEntry{
            kind:       'comment'
            created_at: c.created_at
            user:       u
            comment:    c
        }
    }
    for r in reviews {
        u := app.get_user_by_id(r.author_id) or { continue }
        mut r_comments := []PrReviewCommentWithUser{}
        for rc in rcomments {
            if rc.review_id == r.id {
                uu := app.get_user_by_id(rc.author_id) or { continue }
                r_comments << PrReviewCommentWithUser{
                    item: rc
                    user: uu
                }
            }
        }
        timeline << PrTimelineEntry{
            kind:       'review'
            created_at: r.created_at
            user:       u
            review:     r
            rcomments:  r_comments
        }
    }
    timeline.sort(a.created_at < b.created_at)
    is_repo_owner := repo.user_id == ctx.user.id
    can_merge := is_repo_owner && pr.is_open()
    can_close := pr.is_open() && (is_repo_owner || pr.author_id == ctx.user.id)
    can_reopen := pr.is_closed() && (is_repo_owner || pr.author_id == ctx.user.id)
    ctx.set_page_title(['${pr.title} #${pr.id}', '${repo.user_name}/${repo.name}'])
    return $veb.html('templates/pull.html')
}

// GET /:username/:repo_name/pull/:id/files
@['/:username/:repo_name/pull/:id/files']
pub fn (mut app App) pull_request_files(mut ctx Context, username string, repo_name string, id string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    if !app.has_user_repo_read_access(ctx, ctx.user.id, repo.id) && !repo.is_public {
        return ctx.not_found()
    }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    author := app.get_user_by_id(pr.author_id) or { return ctx.not_found() }
    raw_diff := repo.diff_branches(pr.base_branch, pr.head_branch)
    file_diffs := parse_unified_diff(raw_diff)
    mut all_adds := 0
    mut all_dels := 0
    for fd in file_diffs {
        all_adds += fd.additions
        all_dels += fd.deletions
    }
    file_tree := build_pr_file_tree_rows(file_diffs)
    rcomments := app.get_pr_review_comments(pr.id)
    mut comments_by_key := map[string][]PrReviewCommentWithUser{}
    for rc in rcomments {
        u := app.get_user_by_id(rc.author_id) or { continue }
        key := '${rc.file_path}|${rc.side}|${rc.line_number}'
        comments_by_key[key] << PrReviewCommentWithUser{
            item: rc
            user: u
        }
    }
    can_comment := ctx.logged_in && pr.is_open()
    line_comment_placeholder := veb.tr(ctx.lang.str(), 'pr_line_comment_placeholder').trim_space()
    ctx.set_page_title(['${pr.title} #${pr.id}', 'Files changed', '${repo.user_name}/${repo.name}'])
    return $veb.html('templates/pull_files.html')
}

// POST /:username/:repo_name/pull/:id/comments
@['/:username/:repo_name/pull/:id/comments'; post]
pub fn (mut app App) handle_add_pr_comment(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    text := ctx.form['text']
    if validation.is_string_empty(text) {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.add_pr_comment(pr.id, ctx.user.id, text) or {
        ctx.error('Could not add comment')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.increment_pr_comments(pr.id) or { app.info(err.str()) }
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

// POST /:username/:repo_name/pull/:id/review
@['/:username/:repo_name/pull/:id/review'; post]
pub fn (mut app App) handle_submit_review(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    body := ctx.form['body']
    state_str := ctx.form['state']
    state := match state_str {
        'approved' { 1 }
        'changes_requested' { 2 }
        else { 0 }
    }

    review_id := app.add_pr_review(pr.id, ctx.user.id, state, body) or {
        ctx.error('Could not submit review')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}/files')
    }
    // Attach pending line comments from form (file_path|side|line — text)
    for key, val in ctx.form {
        if !key.starts_with('rc::') {
            continue
        }
        text := val.trim_space()
        if text == '' {
            continue
        }
        // rc::file::side::line
        parts := key[4..].split('::')
        if parts.len < 3 {
            continue
        }
        file_path := parts[0]
        side := parts[1]
        line_no := parts[2].int()
        app.add_pr_review_comment(pr.id, ctx.user.id, review_id, file_path, line_no, side, text) or {
            continue
        }
    }
    if body != '' {
        app.increment_pr_comments(pr.id) or {}
    }
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

// POST /:username/:repo_name/pull/:id/line-comment
@['/:username/:repo_name/pull/:id/line-comment'; post]
pub fn (mut app App) handle_add_line_comment(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    file_path := ctx.form['file_path']
    side := ctx.form['side']
    line_no := ctx.form['line_number'].int()
    text := ctx.form['text']
    if validation.is_string_empty(text) || validation.is_string_empty(file_path) {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}/files')
    }
    app.add_pr_review_comment(pr.id, ctx.user.id, 0, file_path, line_no, side, text) or {
        ctx.error('Could not add line comment')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}/files')
    }
    return ctx.redirect('/${username}/${repo_name}/pull/${id}/files#${file_path}-${side}-${line_no}')
}

// POST /:username/:repo_name/pull/:id/close
@['/:username/:repo_name/pull/:id/close'; post]
pub fn (mut app App) handle_close_pr(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    can_close := repo.user_id == ctx.user.id || pr.author_id == ctx.user.id
    if !can_close {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    if !pr.is_open() {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.set_pr_status(pr.id, .closed) or {
        ctx.error('Could not close PR')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.decrement_repo_open_prs(repo.id) or {}
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

// POST /:username/:repo_name/pull/:id/reopen
@['/:username/:repo_name/pull/:id/reopen'; post]
pub fn (mut app App) handle_reopen_pr(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    can_reopen := repo.user_id == ctx.user.id || pr.author_id == ctx.user.id
    if !can_reopen {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    if !pr.is_closed() {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    if !app.contains_repo_branch(repo.id, pr.head_branch)
        || !app.contains_repo_branch(repo.id, pr.base_branch) {
        ctx.error('Cannot reopen: head or base branch is missing')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.set_pr_status(pr.id, .open) or {
        ctx.error('Could not reopen PR')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.increment_repo_open_prs(repo.id) or {}
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

// POST /:username/:repo_name/pull/:id/merge
@['/:username/:repo_name/pull/:id/merge'; post]
pub fn (mut app App) handle_merge_pr(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    mut repo := app.find_repo_by_name_and_username(repo_name, username) or {
        return ctx.not_found()
    }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    if repo.user_id != ctx.user.id {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    if !pr.is_open() {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    merge_message := 'Merge pull request #${pr.id} from ${pr.head_branch}\n\n${pr.title}'
    merge_hash := merge_branches_in_bare(repo, pr.base_branch, pr.head_branch, ctx.user.username,
        merge_message) or {
        ctx.error('Merge failed: ${err}')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.complete_pr_merge(repo, pr, merge_hash) or {
        ctx.error('Merged but failed to update PR record')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

// POST /:username/:repo_name/pull/:id/squash
@['/:username/:repo_name/pull/:id/squash'; post]
pub fn (mut app App) handle_squash_pr(mut ctx Context, username string, repo_name string, id string) veb.Result {
    if !ctx.logged_in {
        return ctx.redirect_to_login()
    }
    mut repo := app.find_repo_by_name_and_username(repo_name, username) or {
        return ctx.not_found()
    }
    pr := app.find_pull_request_by_id(id.int()) or { return ctx.not_found() }
    if pr.repo_id != repo.id {
        return ctx.not_found()
    }
    if repo.user_id != ctx.user.id {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    if !pr.is_open() {
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    merge_message := 'Squash pull request #${pr.id} from ${pr.head_branch}\n\n${pr.title}'
    merge_hash := squash_branches_in_bare(repo, pr.base_branch, pr.head_branch, ctx.user.username,
        merge_message) or {
        ctx.error('Squash merge failed: ${err}')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    app.complete_pr_merge(repo, pr, merge_hash) or {
        ctx.error('Merged but failed to update PR record')
        return ctx.redirect('/${username}/${repo_name}/pull/${id}')
    }
    return ctx.redirect('/${username}/${repo_name}/pull/${id}')
}

fn (mut app App) complete_pr_merge(repo Repo, pr PullRequest, merge_hash string) ! {
    app.set_pr_merged(pr.id, merge_hash)!
    app.decrement_repo_open_prs(repo.id) or {}
    app.update_repo_branch_after_change(repo.id, pr.base_branch) or {
        app.warn('Failed to update repo after merge: ${err}')
    }
    app.delete_repository_files_in_branch(repo.id, pr.base_branch) or {}
}

// User-scoped PR list
@['/:username/pulls']
pub fn (mut app App) handle_get_user_pulls(mut ctx Context, username string) veb.Result {
    if !ctx.logged_in {
        return ctx.not_found()
    }
    exists, user := app.check_username(username)
    if !exists {
        return ctx.not_found()
    }
    mut prs := app.find_user_pull_requests(user.id)
    mut prs_with_repo := []PullRequest{}
    for mut pr in prs {
        r := app.find_repo_by_id(pr.repo_id) or { continue }
        pr.repo_author = r.user_name
        pr.repo_name = r.name
        prs_with_repo << pr
    }
    ctx.set_page_title(['Pull requests', user.username])
    return $veb.html('templates/user_pulls.html')
}

// --- git helpers ---

// list_commits_between returns commits in head not in base.
fn (r Repo) list_commits_between(base string, head string) []Commit {
    if base == '' || head == '' {
        return []Commit{}
    }
    if !is_safe_ref(base) || !is_safe_ref(head) {
        return []Commit{}
    }
    out :=
        r.git('log ${base}..${head} --pretty=format:%h${log_field_separator}%aE${log_field_separator}%cD${log_field_separator}%s${log_field_separator}%aN')
    mut commits := []Commit{}
    for line in out.split_into_lines() {
        args := line.split(log_field_separator)
        if args.len < 5 {
            continue
        }
        date := time.parse_rfc2822(args[2]) or { time.now() }
        commits << Commit{
            hash:       args[0]
            author:     args[4]
            message:    args[3]
            created_at: int(date.unix())
            author_id:  0
        }
    }
    return commits
}

// diff_branches returns the unified diff between base and head.
fn (r Repo) diff_branches(base string, head string) string {
    if base == '' || head == '' {
        return ''
    }
    if !is_safe_ref(base) || !is_safe_ref(head) {
        return ''
    }
    return r.git('diff --no-color ${base}...${head}')
}

// merge_branches_in_bare performs a merge inside a bare repo using
// git merge-tree to compute the resulting tree, then commit-tree
// and update-ref to advance the base branch. Returns the merge commit hash.
fn merge_branches_in_bare(repo Repo, base string, head string, author string, message string) !string {
    if !is_safe_ref(base) || !is_safe_ref(head) {
        return error('invalid branch name')
    }
    git_dir := repo.git_dir
    base_sha := git_rev_parse(git_dir, base)!
    head_sha := git_rev_parse(git_dir, head)!
    // Try fast-forward first: if base is an ancestor of head, fast-forward.
    if git_is_ancestor(git_dir, base_sha, head_sha) {
        update_branch_ref(git_dir, base, head_sha)!
        return head_sha
    }
    // Use modern merge-tree --write-tree (Git >= 2.38).
    tree_sha := git_merge_tree(git_dir, base_sha, head_sha)!
    commit_sha := git_commit_tree(git_dir, tree_sha, [base_sha, head_sha], author, message)!
    update_branch_ref(git_dir, base, commit_sha)!
    return commit_sha
}

// squash_branches_in_bare computes the merge result and writes one new commit
// on the base branch with only the old base commit as its parent.
fn squash_branches_in_bare(repo Repo, base string, head string, author string, message string) !string {
    if !is_safe_ref(base) || !is_safe_ref(head) {
        return error('invalid branch name')
    }
    git_dir := repo.git_dir
    base_sha := git_rev_parse(git_dir, base)!
    head_sha := git_rev_parse(git_dir, head)!
    tree_sha := git_merge_tree(git_dir, base_sha, head_sha)!
    commit_sha := git_commit_tree(git_dir, tree_sha, [base_sha], author, message)!
    update_branch_ref(git_dir, base, commit_sha)!
    return commit_sha
}

fn git_rev_parse(git_dir string, ref_name string) !string {
    r := git.Git.exec_in_dir(git_dir, ['rev-parse', ref_name])
    if r.exit_code != 0 {
        return error('branch refs missing: ${r.output}')
    }
    sha := r.output.trim_space()
    if sha == '' {
        return error('branch refs missing')
    }
    return sha
}

fn git_is_ancestor(git_dir string, ancestor string, descendant string) bool {
    r := git.Git.exec_in_dir(git_dir, ['merge-base', '--is-ancestor', ancestor, descendant])
    return r.exit_code == 0
}

fn git_merge_tree(git_dir string, base_sha string, head_sha string) !string {
    r := git.Git.exec_in_dir(git_dir, ['merge-tree', '--write-tree', base_sha, head_sha])
    if r.exit_code != 0 {
        return error('merge conflict: cannot auto-merge:\n${r.output}')
    }
    lines := r.output.trim_space().split_into_lines()
    if lines.len == 0 || lines[0] == '' {
        return error('failed to compute merge tree')
    }
    return lines[0]
}

fn git_commit_tree(git_dir string, tree_sha string, parents []string, author string, message string) !string {
    mut args := ['commit-tree', tree_sha]
    for parent in parents {
        args << ['-p', parent]
    }
    args << ['-m', message]
    env := {
        'GIT_AUTHOR_NAME':     author
        'GIT_AUTHOR_EMAIL':    '${author}@gitly'
        'GIT_COMMITTER_NAME':  author
        'GIT_COMMITTER_EMAIL': '${author}@gitly'
    }
    r := git.Git.exec_in_dir_with_env(git_dir, args, env)
    if r.exit_code != 0 {
        return error('commit-tree failed: ${r.output}')
    }
    commit_sha := r.output.trim_space()
    if commit_sha == '' {
        return error('commit-tree produced no commit')
    }
    return commit_sha
}

fn update_branch_ref(git_dir string, branch string, commit_sha string) ! {
    r := git.Git.exec_in_dir(git_dir, ['update-ref', 'refs/heads/${branch}', commit_sha])
    if r.exit_code != 0 {
        return error('update-ref failed: ${r.output}')
    }
}

fn pr_diff_table_html(fd FileDiff, comments_by_key map[string][]PrReviewCommentWithUser, can_comment bool) string {
    mut out := strings.new_builder(1024)
    out.write_string('<div class=pr-diff__table>')
    for hunk in fd.hunks {
        out.write_string(diff_hunk_header_html(hunk.header))
        for dline in hunk.lines {
            attrs := if can_comment && dline.kind != 'context' {
                ' s=${dline.compact_side()} l=${dline.effective_line()}'
            } else {
                ''
            }
            out.write_string(diff_line_row_html_with_attrs(fd.path, dline, attrs))
            out.write_string(inline_comments_html(fd.path, dline, comments_by_key))
        }
    }
    out.write_string('</div>')
    return out.str()
}

// inline_comments_html returns any line comments attached to a given diff line,
// matched on file_path, side, and line_number.
fn inline_comments_html(file_path string, dline DiffLine, comments_by_key map[string][]PrReviewCommentWithUser) string {
    mut side := ''
    mut line_no := 0
    if dline.kind == 'add' {
        side = 'new'
        line_no = dline.new_line
    } else if dline.kind == 'del' {
        side = 'old'
        line_no = dline.old_line
    } else {
        return ''
    }
    key := '${file_path}|${side}|${line_no}'
    list := comments_by_key[key] or { return '' }
    if list.len == 0 {
        return ''
    }
    mut out := ''
    for c in list {
        body := html_escape_text(c.item.text)
        username := html_escape_text(c.user.username)
        rel := html_escape_text(c.item.relative())
        out += '<p class=n><b>${username}</b> <i>commented ${rel}</i><br><s>${body}</s></p>'
    }
    return out
}

// is_safe_ref does a strict whitelist check for branch names used in shell.
fn is_safe_ref(name string) bool {
    if name == '' {
        return false
    }
    for ch in name {
        if !(ch.is_letter() || ch.is_digit() || ch in [`-`, `_`, `.`, `/`]) {
            return false
        }
    }
    if name.starts_with('-') || name.contains('..') {
        return false
    }
    return true
}