package zet

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path"
	"regexp"
	"sort"
	"strconv"
	"strings"

	"code.oliverdavies.uk/opdavies/cmd-zet/internal/config"
	"code.oliverdavies.uk/opdavies/cmd-zet/internal/file"
	"code.oliverdavies.uk/opdavies/cmd-zet/internal/git"
)

func CreateZet(title string) {
	zid := newZid()

	path := path.Join(config.GetZetDir(), strconv.Itoa(zid))

	os.Mkdir(path, 0750)

	filePath := fmt.Sprintf("%s/index.adoc", path)

	f, err := os.Create(filePath)

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	_, err = fmt.Fprintf(f, "= %s", title)

	if err != nil {
		log.Fatal(err)
	}

	file.Edit(filePath)

	onSave(zid)
}

func EditZet(id int) {
	zetPath := path.Join(config.GetZetDir(), strconv.Itoa(id), "index.adoc")

	file.Edit(zetPath)

	onSave(id)
}

func GetAllZets() []int {
	zets, err := git.ExecGitCommand("ls-files")

	if err != nil {
		log.Println(err)
	}

	re := regexp.MustCompile(`[0-9]+`)
	matches := re.FindAllString(zets, -1)

	sort.Strings(matches)

	ids := make(map[int]struct{})
	for _, id := range matches {
		num, err := strconv.Atoi(id)

		if err == nil {
			ids[num] = struct{}{}
		}
	}

	var sorted []int
	for num := range ids {
		sorted = append(sorted, num)
	}

	sort.Ints(sorted)

	return sorted
}

func GetLatestZet() int {
	z := GetAllZets()

	return z[len(z)-1]
}

func SearchZets(query string) []int {
	zets, err := git.ExecGitCommand("grep", "-i", "--name-only", "--word-regex", query)

	if err != nil {
		fmt.Printf("No matches found for %s.\n", query)

		os.Exit(1)
	}

	re := regexp.MustCompile(`[0-9]+`)
	matches := re.FindAllString(zets, -1)

	sort.Strings(matches)

	ids := make(map[int]struct{})
	for _, id := range matches {
		num, err := strconv.Atoi(id)

		if err == nil {
			ids[num] = struct{}{}
		}
	}

	var sorted []int
	for num := range ids {
		sorted = append(sorted, num)
	}

	sort.Ints(sorted)

	return sorted
}

func ParseZetList(ids []int) []string {
	var lines []string

	green := "\033[32m"
	reset := "\033[0m"

	for _, num := range ids {
		line := fmt.Sprintf("%s%s%s %s", green, strconv.Itoa(num), reset, getTitle(num))

		lines = append(lines, line)
	}

	return lines
}

func ViewZet(id int) string {
	zetPath := path.Join(config.GetZetDir(), strconv.Itoa(id), "index.adoc")

	return file.View(zetPath)
}

func getTitle(id int) string {
	return getTitleFromFile(path.Join(strconv.Itoa(id), "index.adoc"))
}

func getTitleFromFile(filePath string) string {
	filePath = path.Join(config.GetZetDir(), filePath)

	file, err := os.Open(filePath)

	if err != nil {
		fmt.Println("Error opening file:", err)

		return ""
	}

	defer file.Close()

	scanner := bufio.NewScanner(file)

	if scanner.Scan() {
		text := scanner.Text()

		return strings.TrimPrefix(text, "= ")
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("Error reading file:", err)
	}

	return ""
}

func newZid() int {
	cmd := exec.Command("ls", config.GetZetDir())
	output, _ := cmd.CombinedOutput()

	zets := strings.Split(string(output), "\n")

	var zetCount int

	for _, zet := range zets {
		num, err := strconv.Atoi(zet)
		if err == nil && num > zetCount {
			zetCount = num
		}
	}

	return zetCount + 1
}

func onSave(id int) {
	title := getTitle(id)

	git.CommitZettel(id, title)

	// TODO: Or delete the file if empty.
}