module main

import veb
import os
import git

// GET /:username/:repo_name/new/:branch_name - Show create file form
@['/:username/:repo_name/new/:branch_name']
pub fn (mut app App) new_file(username string, repo_name string, branch_name string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }

    if !ctx.logged_in || repo.user_id != ctx.user.id {
        return ctx.redirect_to_repository(username, repo_name)
    }

    default_content := ''
    default_filename := ''
    return $veb.html('templates/new_file.html')
}

// GET /:username/:repo_name/new-ci-file - Show create .gitly-ci.yml form (pre-filled)
@['/:username/:repo_name/new-ci-file']
pub fn (mut app App) new_ci_file(username string, repo_name string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }

    if !ctx.logged_in || repo.user_id != ctx.user.id {
        return ctx.redirect_to_repository(username, repo_name)
    }

    branch_name := repo.primary_branch
    default_filename := '.gitly-ci.yml'
    default_content := 'jobs:
  build:
    steps:
      - name: Build
        run: echo "hello world"
      - name: Test
        run: echo "running tests"
'
    return $veb.html('templates/new_file.html')
}

// GET /:username/:repo_name/edit/:branch_name/:path... - Show edit file form
@['/:username/:repo_name/edit/:branch_name/:path...']
pub fn (mut app App) edit_file(username string, repo_name string, branch_name string, path string) veb.Result {
    repo := app.find_repo_by_name_and_username(repo_name, username) or { return ctx.not_found() }

    if !ctx.logged_in || repo.user_id != ctx.user.id {
        return ctx.redirect_to_repository(username, repo_name)
    }

    file_content := repo.read_file(branch_name, path)

    return $veb.html('templates/edit_file.html')
}

// POST /:username/:repo_name/update-file - Save edited file
@['/:username/:repo_name/update-file'; post]
pub fn (mut app App) handle_update_file(username string, repo_name string) veb.Result {
    mut repo := app.find_repo_by_name_and_username(repo_name, username) or {
        return ctx.not_found()
    }

    if !ctx.logged_in || repo.user_id != ctx.user.id {
        return ctx.redirect_to_repository(username, repo_name)
    }

    file_path := ctx.form['file_path']
    file_content := ctx.form['file_content']
    branch_name := ctx.form['branch']
    commit_message := ctx.form['commit_message']
    mut actual_branch := ''

    if commit_message == '' {
        ctx.error('Commit message is required')
        path := file_path
        return $veb.html('templates/edit_file.html')
    }

    actual_branch = branch_name
    if actual_branch == '' {
        actual_branch = repo.primary_branch
    }

    success := app.create_file_in_bare_repo(mut repo, actual_branch, file_path, file_content,
        commit_message, ctx.user.username)

    if !success {
        ctx.error('Failed to save file')
        path := file_path
        return $veb.html('templates/edit_file.html')
    }

    // Clear cached files so the updated file shows up
    app.delete_repository_files_in_branch(repo.id, actual_branch) or {}

    app.update_repo_after_push(repo.id, actual_branch) or {
        app.warn('Failed to update repo after file edit: ${err}')
    }

    // Trigger CI if applicable
    if file_path == '.gitly-ci.yml' {
        spawn app.trigger_ci_with_config(repo.id, actual_branch, file_content)
    } else {
        spawn app.trigger_ci_if_configured(repo.id, actual_branch)
    }

    return ctx.redirect('/${username}/${repo_name}/blob/${actual_branch}/${file_path}')
}

// POST /:username/:repo_name/create-file - Create a file in the repo
@['/:username/:repo_name/create-file'; post]
pub fn (mut app App) handle_create_file(username string, repo_name string) veb.Result {
    mut repo := app.find_repo_by_name_and_username(repo_name, username) or {
        return ctx.not_found()
    }

    if !ctx.logged_in || repo.user_id != ctx.user.id {
        return ctx.redirect_to_repository(username, repo_name)
    }

    file_path := ctx.form['file_path']
    file_content := ctx.form['file_content']
    branch_name := ctx.form['branch']
    commit_message := ctx.form['commit_message']
    mut actual_branch := ''

    if file_path == '' {
        ctx.error('File path is required')
        default_content := file_content
        default_filename := file_path
        return $veb.html('templates/new_file.html')
    }

    if commit_message == '' {
        ctx.error('Commit message is required')
        default_content := file_content
        default_filename := file_path
        return $veb.html('templates/new_file.html')
    }

    // Sanitize file path
    if file_path.contains('..') || file_path.contains('&') || file_path.contains(';') {
        ctx.error('Invalid file path')
        default_content := file_content
        default_filename := file_path
        return $veb.html('templates/new_file.html')
    }

    actual_branch = branch_name
    if actual_branch == '' {
        actual_branch = repo.primary_branch
    }

    success := app.create_file_in_bare_repo(mut repo, actual_branch, file_path, file_content,
        commit_message, ctx.user.username)

    if !success {
        ctx.error('Failed to create file')
        default_content := file_content
        default_filename := file_path
        return $veb.html('templates/new_file.html')
    }

    // Clear cached files so the new file shows up
    app.delete_repository_files_in_branch(repo.id, actual_branch) or {}

    // Update repo data
    app.update_repo_after_push(repo.id, actual_branch) or {
        app.warn('Failed to update repo after file creation: ${err}')
    }

    // Trigger CI — if we just created .gitly-ci.yml, pass the content directly
    if file_path == '.gitly-ci.yml' {
        spawn app.trigger_ci_with_config(repo.id, actual_branch, file_content)
    } else {
        spawn app.trigger_ci_if_configured(repo.id, actual_branch)
    }

    return ctx.redirect('/${username}/${repo_name}')
}

// Creates a file in a bare git repo using plumbing commands
fn (mut app App) create_file_in_bare_repo(mut repo Repo, branch string, file_path string, content string, message string, author string) bool {
    git_dir := repo.git_dir
    app.info('Creating file ${file_path} in ${git_dir} on branch ${branch}')

    // Validate untrusted inputs before they reach git. Every git invocation
    // below passes its arguments as an array (never through a shell), but we
    // still reject values git itself could treat as flags/refs or that contain
    // control characters. This guards both the create-file and update-file
    // routes, which both funnel through here.
    if !is_safe_ref(branch) {
        app.warn('Refusing to write file: invalid branch name "${branch}"')
        return false
    }
    if !is_valid_repo_file_path(file_path) {
        app.warn('Refusing to write file: invalid file path "${file_path}"')
        return false
    }

    // Write content to a temp file, then hash it into git
    tmp_file := os.join_path(os.temp_dir(), 'gitly_newfile_${repo.id}_${os.getpid()}')
    os.write_file(tmp_file, content) or {
        app.warn('Failed to write temp file: ${err}')
        return false
    }
    defer {
        os.rm(tmp_file) or {}
    }

    // 1. Hash the blob into the object store
    hash_res := git.Git.exec_in_dir(git_dir, ['hash-object', '-w', tmp_file])
    if hash_res.exit_code != 0 {
        app.warn('hash-object failed: ${hash_res.output}')
        return false
    }
    blob_hash := hash_res.output.trim_space()
    if blob_hash == '' {
        app.warn('hash-object produced no hash')
        return false
    }

    // 2. Find the current tree and parent commit for this branch (both may be
    //    empty when committing to a brand-new branch).
    tree_res := git.Git.exec_in_dir(git_dir, ['rev-parse', '${branch}^{tree}'])
    existing_tree := if tree_res.exit_code == 0 { tree_res.output.trim_space() } else { '' }
    has_existing_tree := existing_tree != ''

    parent_res := git.Git.exec_in_dir(git_dir, ['rev-parse', branch])
    parent_commit := if parent_res.exit_code == 0 { parent_res.output.trim_space() } else { '' }

    // 3. Build the new tree inside an isolated temp index, so neither the
    //    repo's own index nor a concurrent edit of the same repo is affected.
    //    Starting from an empty index (no read-tree) handles the new-branch
    //    case without needing `mktree`.
    tmp_index := os.join_path(os.temp_dir(), 'gitly_index_${repo.id}_${os.getpid()}')
    os.rm(tmp_index) or {}
    defer {
        os.rm(tmp_index) or {}
    }
    index_env := {
        'GIT_INDEX_FILE': tmp_index
    }

    if has_existing_tree {
        read_res := git.Git.exec_in_dir_with_env(git_dir, ['read-tree', existing_tree], index_env)
        if read_res.exit_code != 0 {
            app.warn('read-tree failed: ${read_res.output}')
            return false
        }
    }

    add_res := git.Git.exec_in_dir_with_env(git_dir, ['update-index', '--add', '--cacheinfo',
        '100644,${blob_hash},${file_path}'], index_env)
    if add_res.exit_code != 0 {
        app.warn('update-index failed: ${add_res.output}')
        return false
    }

    write_res := git.Git.exec_in_dir_with_env(git_dir, ['write-tree'], index_env)
    if write_res.exit_code != 0 {
        app.warn('write-tree failed: ${write_res.output}')
        return false
    }
    new_tree_hash := write_res.output.trim_space()
    if new_tree_hash == '' {
        app.warn('Failed to create tree')
        return false
    }

    // 4. Create the commit. The message and author are passed as plain
    //    arguments / environment values, so any shell metacharacters they
    //    contain are inert.
    mut commit_args := ['commit-tree', new_tree_hash]
    if parent_commit != '' {
        commit_args << ['-p', parent_commit]
    }
    commit_args << ['-m', message]
    commit_env := {
        'GIT_AUTHOR_NAME':     author
        'GIT_AUTHOR_EMAIL':    '${author}@gitly'
        'GIT_COMMITTER_NAME':  author
        'GIT_COMMITTER_EMAIL': '${author}@gitly'
    }
    r4 := git.Git.exec_in_dir_with_env(git_dir, commit_args, commit_env)
    if r4.exit_code != 0 {
        app.warn('commit-tree failed: ${r4.output}')
        return false
    }
    new_commit_hash := r4.output.trim_space()

    // 5. Update the branch ref
    r5 := git.Git.exec_in_dir(git_dir, ['update-ref', 'refs/heads/${branch}', new_commit_hash])
    if r5.exit_code != 0 {
        app.warn('update-ref failed: ${r5.output}')
        return false
    }

    app.info('File ${file_path} created with commit ${new_commit_hash}')
    return true
}

// is_valid_repo_file_path rejects empty/over-long paths, absolute paths, leading
// dashes, parent-directory traversal, and any control characters (including NUL
// and newlines).
fn is_valid_repo_file_path(path string) bool {
    if path.len == 0 || path.len > 4096 {
        return false
    }
    if path.starts_with('/') || path.starts_with('-') || path.contains('..') {
        return false
    }
    for c in path {
        if c < 0x20 || c == 0x7f {
            return false
        }
    }
    return true
}