package main

import (
	"embed"
	"encoding/base64"
	"fmt"
	"html/template"
	"os"
	"path/filepath"
	"strings"

	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing/filemode"
	"github.com/go-git/go-git/v5/plumbing/object"
)

//go:embed icons/*.png
var iconsFS embed.FS

//go:embed templates/*.tmpl
var templatesFS embed.FS

var icons map[string]string
var templates *template.Template

const DOMAIN = "https://git.mcksp.com"

type Config struct {
	outputPath   string
	filesPath    string
	repoName     string
	description  string
	lastModified string
}

type Entry struct {
	Name string
	Path string
}

type IndexData struct {
	RepoName       string
	Description    string
	Domain         string
	Directories    []Entry
	Files          []Entry
	ReadmeContent  string
	HasReadme      bool
	LastModified   string
	Icons          map[string]string
	PathPrefix     string
}

type FileData struct {
	IsBinary    bool
	ShowLines   bool
	LineNumbers []int
	Content     string
}

func basename(path string) string {
	return filepath.Base(path)
}

func countLines(s string) int {
	lines := 0
	for _, c := range s {
		if c == '\n' {
			lines++
		}
	}
	return lines
}

func joinPaths(path1, path2 string) string {
	if path1 == "" {
		return path2
	}
	if strings.HasSuffix(path1, "/") {
		return path1 + path2
	}
	return path1 + "/" + path2
}

func htmlEncode(content string) string {
	var sb strings.Builder
	for _, c := range content {
		switch c {
		case '<':
			sb.WriteString("&lt;")
		case '>':
			sb.WriteString("&gt;")
		case '\'':
			sb.WriteString("&#39;")
		case '&':
			sb.WriteString("&amp;")
		case '"':
			sb.WriteString("&quot;")
		default:
			sb.WriteRune(c)
		}
	}
	return sb.String()
}

func processFile(repo *git.Repository, file *object.File, root, name string, conf *Config) {
	content, err := file.Contents()
	if err != nil {
		fmt.Printf("cannot get file contents: %v\n", err)
		return
	}

	path := fmt.Sprintf("%s/%s/%s.html", conf.filesPath, root, name)
	f, err := os.Create(path)
	if err != nil {
		fmt.Printf("couldnt open file %s: %v\n", path, err)
		return
	}
	defer f.Close()

	data := FileData{
		IsBinary:  isBinary(content),
		ShowLines: true,
	}

	if !data.IsBinary {
		lineCount := countLines(content)
		data.LineNumbers = make([]int, lineCount)
		for i := 0; i < lineCount; i++ {
			data.LineNumbers[i] = i + 1
		}
		data.Content = content
	}

	err = templates.ExecuteTemplate(f, "file.tmpl", data)
	if err != nil {
		fmt.Printf("template execution error: %v\n", err)
	}
}

func isBinary(s string) bool {
	for i := 0; i < len(s) && i < 8000; i++ {
		if s[i] == 0 {
			return true
		}
	}
	return false
}

func processTree(repo *git.Repository, tree *object.Tree, treePath string, conf *Config, isRoot bool) {
	dirPath := joinPaths(conf.filesPath, treePath)
	os.MkdirAll(dirPath, 0755)

	var indexPath string
	if isRoot {
		indexPath = fmt.Sprintf("%s/index.html", conf.outputPath)
	} else {
		indexPath = fmt.Sprintf("%s.html", joinPaths(conf.filesPath, treePath))
	}

	f, err := os.Create(indexPath)
	if err != nil {
		fmt.Printf("couldnt create index: %v\n", err)
		return
	}
	defer f.Close()

	pathPrefix := ""
	if isRoot {
		pathPrefix = "files/"
	}

	data := IndexData{
		RepoName:     conf.repoName,
		Description:  conf.description,
		Domain:       DOMAIN,
		Directories:  []Entry{},
		Files:        []Entry{},
		LastModified: conf.lastModified,
		Icons:        icons,
		PathPrefix:   pathPrefix,
	}

	// Collect directories first
	for _, entry := range tree.Entries {
		if entry.Mode == filemode.Dir {
			childName := entry.Name
			childPath := joinPaths(treePath, childName)

			data.Directories = append(data.Directories, Entry{
				Name: childName,
				Path: childPath,
			})

			childTree, err := repo.TreeObject(entry.Hash)
			if err != nil {
				fmt.Printf("couldnt find tree for %s: %v\n", childPath, err)
				continue
			}
			processTree(repo, childTree, childPath, conf, false)
		}
	}

	// Collect files second
	for _, entry := range tree.Entries {
		if entry.Mode == filemode.Regular || entry.Mode == filemode.Executable {
			childName := entry.Name
			childPath := joinPaths(treePath, childName)

			data.Files = append(data.Files, Entry{
				Name: childName,
				Path: childPath,
			})

			file, err := tree.File(childName)
			if err != nil {
				fmt.Printf("couldnt get file %s: %v\n", childName, err)
				continue
			}
			processFile(repo, file, treePath, childName, conf)
		}
	}

	// Add README if this is root
	if isRoot {
		readme, err := tree.File("README")
		if err == nil {
			content, err := readme.Contents()
			if err == nil {
				data.ReadmeContent = content
				data.HasReadme = true
			}
		}
	}

	err = templates.ExecuteTemplate(f, "index.tmpl", data)
	if err != nil {
		fmt.Printf("template execution error: %v\n", err)
	}
}

func removeExt(repoName string) string {
	if idx := strings.LastIndex(repoName, "."); idx != -1 {
		return repoName[:idx]
	}
	return repoName
}

func loadIcons() {
	icons = make(map[string]string)
	iconFiles := []string{"dir.png", "text.png", "image.png", "blob.png", "gituwa.png"}

	for _, iconFile := range iconFiles {
		data, err := iconsFS.ReadFile("icons/" + iconFile)
		if err != nil {
			fmt.Printf("warning: could not load icon %s: %v\n", iconFile, err)
			continue
		}
		encoded := base64.StdEncoding.EncodeToString(data)
		icons[iconFile] = "data:image/png;base64," + encoded
	}
}

func loadTemplates() {
	var err error
	funcMap := template.FuncMap{
		"iconSrc": func(iconName string, icons map[string]string) template.HTMLAttr {
			return template.HTMLAttr(fmt.Sprintf("src='%s'", icons[iconName]))
		},
		"htmlEncode": func(s string) template.HTML {
			return template.HTML(htmlEncode(s))
		},
	}
	templates, err = template.New("").Funcs(funcMap).ParseFS(templatesFS, "templates/*.tmpl")
	if err != nil {
		fmt.Printf("error loading templates: %v\n", err)
		os.Exit(1)
	}
}

func main() {
	loadIcons()
	loadTemplates()

	args := os.Args

	if len(args) < 3 {
		fmt.Println("usage: gituwa <repo_path> <output_path> <description>")
		return
	}

	repoPath := args[1]
	outputPath := args[2]
	filesPath := joinPaths(outputPath, "files")

	description := ""
	if len(args) > 3 {
		description = strings.Join(args[3:], " ")
	}

	repo, err := git.PlainOpen(repoPath)
	if err != nil {
		fmt.Printf("cannot open repository: %v\n", err)
		return
	}

	repoName := removeExt(basename(repoPath))

	head, err := repo.Head()
	if err != nil {
		fmt.Printf("cannot get HEAD: %v\n", err)
		return
	}

	commit, err := repo.CommitObject(head.Hash())
	if err != nil {
		fmt.Printf("cannot get commit: %v\n", err)
		return
	}

	tree, err := commit.Tree()
	if err != nil {
		fmt.Printf("cannot get tree: %v\n", err)
		return
	}

	// Format the commit timestamp
	lastModified := commit.Author.When.Format("2006-01-02 15:04:05")

	conf := &Config{
		outputPath:   outputPath,
		filesPath:    filesPath,
		repoName:     repoName,
		description:  description,
		lastModified: lastModified,
	}

	os.MkdirAll(conf.outputPath, 0755)
	os.MkdirAll(conf.filesPath, 0755)

	processTree(repo, tree, "", conf, true)
}