module git

import os
import time

pub const clone_size_limit_exit_code = 125
pub const clone_size_limit_marker = '[gitly:clone-size-limit]'

pub struct Git {}

pub fn Git.exec(args []string) os.Result {
	mut git_args := ['git']
	git_args << args
	return os.exec(git_args)
}

pub fn Git.exec_in_dir(dir string, args []string) os.Result {
	mut git_args := ['-C', dir]
	git_args << args
	return Git.exec(git_args)
}

pub fn Git.exec_in_dir_command(dir string, command string) os.Result {
	return Git.exec_in_dir(dir, split_command(command))
}

pub fn Git.exec_shell(command string) os.Result {
	return os.exec(['/bin/sh', '-c', command])
}

// Git.exec_in_dir_with_env runs `git -C <dir> <args...>` without going through a
// shell, with `extra_env` added on top of the inherited environment. Use this
// instead of building a shell string when any argument or environment value is
// user-controlled (file paths, branch names, commit messages, author names),
// since arguments are passed directly to git and never re-parsed by /bin/sh.
pub fn Git.exec_in_dir_with_env(dir string, args []string, extra_env map[string]string) os.Result {
	mut full_args := ['-C', dir]
	full_args << args
	mut p := os.new_process('git')
	p.set_args(full_args)
	mut merged := os.environ()
	for k, v in extra_env {
		merged[k] = v
	}
	p.set_environment(merged)
	p.set_redirect_stdio()
	p.run()
	output := p.stdout_slurp() + p.stderr_slurp()
	p.wait()
	code := p.code
	p.close()
	return os.Result{
		exit_code: code
		output:    output
	}
}

pub fn Git.clone(url string, path string) os.Result {
	println('new clone url="${url}" path="${path}"')
	return os.exec(['git', 'clone', '--bare', url, path])
}

// Git.clone_with_progress runs `git clone --bare --progress` and streams
// every byte of git's progress output (which goes to stderr) into
// `progress_path` while the clone is running, so a separate process can
// poll the file and show live progress to the user.
pub fn Git.clone_with_progress(url string, path string, progress_path string) os.Result {
	return Git.clone_with_progress_limit(url, path, progress_path, 0)
}

pub fn Git.clone_with_progress_limit(url string, path string, progress_path string, max_bytes u64) os.Result {
	println('new clone (progress) url="${url}" path="${path}" progress="${progress_path}"')
	os.rm(progress_path) or {}
	mut p := os.new_process('git')
	p.set_args(['clone', '--bare', '--progress', url, path])
	p.set_redirect_stdio()
	p.run()
	mut log := os.open_append(progress_path) or {
		eprintln('clone_with_progress: cannot open progress file "${progress_path}": ${err}')
		// fall back to non-streaming behaviour
		p.wait()
		out := p.stdout_slurp() + p.stderr_slurp()
		code := p.code
		p.close()
		return os.Result{
			exit_code: code
			output:    out
		}
	}
	mut collected := ''
	mut stopped_for_size := false
	for p.is_alive() {
		chunk := p.stderr_read()
		if chunk.len > 0 {
			log.write_string(chunk) or {}
			log.flush()
			collected += chunk
			if max_bytes > 0 && !stopped_for_size
				&& clone_progress_received_bytes(collected) >= max_bytes {
				stopped_for_size = true
				marker := '\n${clone_size_limit_marker}\n'
				log.write_string(marker) or {}
				log.flush()
				collected += marker
				p.signal_term()
				time.sleep(500 * time.millisecond)
				if p.is_alive() {
					p.signal_kill()
				}
			}
		}
		// drain stdout so the pipe buffer never blocks the child
		_ := p.stdout_read()
		time.sleep(100 * time.millisecond)
	}
	final := p.stderr_slurp()
	if final.len > 0 {
		log.write_string(final) or {}
		log.flush()
		collected += final
	}
	log.close()
	p.wait()
	exit_code := if stopped_for_size { clone_size_limit_exit_code } else { p.code }
	p.close()
	return os.Result{
		exit_code: exit_code
		output:    collected
	}
}

pub fn clone_progress_received_bytes(progress string) u64 {
	mut max_bytes := u64(0)
	for line in progress.replace('\r', '\n').split('\n') {
		if !line.contains('Receiving objects:') {
			continue
		}
		bytes := parse_clone_progress_size(line) or { continue }
		if bytes > max_bytes {
			max_bytes = bytes
		}
	}
	return max_bytes
}

fn parse_clone_progress_size(line string) ?u64 {
	comma := line.index('),') or { return none }
	mut size_part := line[comma + 2..].trim_space()
	pipe := size_part.index('|') or { size_part.len }
	size_part = size_part[..pipe].trim_space()
	parts := size_part.fields()
	if parts.len < 2 {
		return none
	}
	value := parts[0].f64()
	multiplier := match parts[1] {
		'B', 'byte', 'bytes' { 1.0 }
		'KiB' { 1024.0 }
		'MiB' { 1024.0 * 1024.0 }
		'GiB' { 1024.0 * 1024.0 * 1024.0 }
		else { return none }
	}

	return u64(value * multiplier)
}

pub fn Git.fetch_ref(repo_dir string, remote string, refspec string) os.Result {
	return Git.exec_in_dir(repo_dir, ['fetch', remote, refspec])
}

pub fn Git.show_file_blob(repo_dir string, branch string, file_path string) !string {
	result := Git.exec_in_dir(repo_dir, ['--no-pager', 'show', '${branch}:${file_path}'])
	if result.exit_code != 0 {
		return error(result.output)
	}
	return result.output
}

fn split_command(command string) []string {
	mut args := []string{}
	mut current := []u8{}
	mut quote := u8(0)
	mut escaped := false

	for ch in command.bytes() {
		if escaped {
			current << ch
			escaped = false
			continue
		}
		if ch == `\\` {
			escaped = true
			continue
		}
		if quote != 0 {
			if ch == quote {
				quote = 0
			} else {
				current << ch
			}
			continue
		}
		if ch == `"` || ch == `'` {
			quote = ch
			continue
		}
		if ch.is_space() {
			if current.len > 0 {
				args << current.bytestr()
				current.clear()
			}
			continue
		}
		current << ch
	}
	if current.len > 0 {
		args << current.bytestr()
	}
	return args
}