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}')

	// Write content to a temp file, then hash it into git
	tmp_file := '/tmp/gitly_newfile_${repo.id}'
	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
	blob_hash := sh('git -C ${git_dir} hash-object -w ${tmp_file}')
	if blob_hash == '' {
		app.warn('hash-object failed')
		return false
	}

	// 2. Read the current tree for this branch (if it exists)
	mut parent_commit := ''
	existing_tree := sh('git -C ${git_dir} rev-parse "${branch}^{tree}"')
	has_existing_tree := existing_tree != ''

	// Get parent commit hash
	parent_commit = sh('git -C ${git_dir} rev-parse ${branch}')

	// 3. Build a new tree
	mut new_tree_hash := ''
	if has_existing_tree {
		tmp_index := '/tmp/gitly_index_${repo.id}'
		defer {
			os.rm(tmp_index) or {}
		}

		// Read existing tree into temp index
		r1 :=
			git.Git.exec_shell('GIT_INDEX_FILE=${tmp_index} git -C ${git_dir} read-tree ${existing_tree}')
		if r1.exit_code != 0 {
			app.warn('read-tree failed: ${r1.output}')
			return false
		}

		// Add the new blob to the index
		r2 :=
			git.Git.exec_shell('GIT_INDEX_FILE=${tmp_index} git -C ${git_dir} update-index --add --cacheinfo 100644,${blob_hash},${file_path}')
		if r2.exit_code != 0 {
			app.warn('update-index failed: ${r2.output}')
			return false
		}

		// Write the tree
		r3 := git.Git.exec_shell('GIT_INDEX_FILE=${tmp_index} git -C ${git_dir} write-tree')
		if r3.exit_code != 0 {
			app.warn('write-tree failed: ${r3.output}')
			return false
		}
		new_tree_hash = r3.output.trim_space()
	} else {
		// No existing tree — create from scratch using mktree
		tree_entry := '100644 blob ${blob_hash}\t${file_path}'
		tmp_tree := '/tmp/gitly_tree_${repo.id}'
		os.write_file(tmp_tree, tree_entry + '\n') or { return false }
		defer {
			os.rm(tmp_tree) or {}
		}
		r := git.Git.exec_shell('git -C ${git_dir} mktree < ${tmp_tree}')
		if r.exit_code != 0 {
			app.warn('mktree failed: ${r.output}')
			return false
		}
		new_tree_hash = r.output.trim_space()
	}

	if new_tree_hash == '' {
		app.warn('Failed to create tree')
		return false
	}

	// 4. Create a commit
	mut parent_flag := ''
	if parent_commit != '' {
		parent_flag = '-p ${parent_commit}'
	}

	commit_sh := 'GIT_AUTHOR_NAME="${author}" GIT_AUTHOR_EMAIL="${author}@gitly" GIT_COMMITTER_NAME="${author}" GIT_COMMITTER_EMAIL="${author}@gitly" git -C ${git_dir} commit-tree ${new_tree_hash} ${parent_flag} -m "${message}"'
	r4 := git.Git.exec_shell(commit_sh)
	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
}

fn sh(cmd string) string {
	r := git.Git.exec_shell(cmd)
	if r.exit_code != 0 {
		return ''
	}
	return r.output.trim_space()
}