module git

import os
import time

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

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 {
	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 := ''
	for p.is_alive() {
		chunk := p.stderr_read()
		if chunk.len > 0 {
			log.write_string(chunk) or {}
			log.flush()
			collected += chunk
		}
		// 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 := p.code
	p.close()
	return os.Result{
		exit_code: exit_code
		output:    collected
	}
}

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
}