package server

import (
	"html"
	"html/template"
	"net/url"
	"sort"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/highlight"
)

// largeChange is het aantal toegevoegde en verwijderde regels waarna een diff dicht blijft.
const largeChange = 200

// CommitDiff is de diff van één commit.
type CommitDiff struct {
	Parents                []ParentSHA
	Files                  []CommitFile
	Tree                   []CommitTreeRow
	Added, Deleted, FilesN int
}

// ParentSHA is een parent van de commit.
type ParentSHA struct {
	SHA, Short string
}

// CommitFile is één gewijzigd bestand, in unified en side-by-side vorm.
type CommitFile struct {
	Path, OldPath, Status, Anchor, FileURL string
	Added, Deleted                         int
	Binary, Collapsed, HasBody             bool
	Lines                                  []CommitLine
	Pairs                                  []CommitPair
}

// CommitLine is één unified diffregel. HTML is al geëscaped.
type CommitLine struct {
	Kind  string
	Old   int
	New   int
	HTML  template.HTML
	Notes []NoteRow
}

// CommitPair is één rij in de naast-elkaar-weergave.
type CommitPair struct {
	Hunk         string
	LKind, RKind string
	LNo, RNo     int
	LHTML, RHTML template.HTML
}

// CommitTreeRow is een map of bestand in de boom.
type CommitTreeRow struct {
	Name, Path, Anchor, Status, Icon string
	Dir                              bool
	Depth, Added, Deleted            int
}

func presentCommitDiff(repoPath, sha string, parents []string, files []gitrepo.PatchFile) *CommitDiff {
	d := &CommitDiff{}
	for _, p := range parents {
		if !safeSHA(p) {
			continue
		}
		d.Parents = append(d.Parents, ParentSHA{SHA: p, Short: shortSHA(p)})
	}
	parent := ""
	if len(d.Parents) > 0 {
		parent = d.Parents[0].SHA
	}
	seen := map[string]int{}
	for _, f := range files {
		if f.Path == "" {
			continue
		}
		cf := CommitFile{
			Path: f.Path, OldPath: f.OldPath, Status: f.Status,
			Added: f.Added, Deleted: f.Deleted, Binary: f.Binary,
			Anchor:    diffAnchor(f.Path, seen),
			Collapsed: !f.Binary && f.Added+f.Deleted > largeChange,
		}
		linkPath := f.Path
		linkRev := sha
		if f.Status == "deleted" {
			linkPath = f.Path
			linkRev = parent
		}
		if linkRev != "" {
			cf.FileURL = blobLink(repoPath, linkRev, linkPath)
		}
		if f.Binary || len(f.Lines) > 0 {
			cf.HasBody = true
		}
		if !f.Binary && len(f.Lines) > 0 {
			name := f.Path
			if f.Status == "deleted" {
				name = f.Path
			}
			painter := highlight.NewPainter(name)
			for _, ln := range f.Lines {
				row := CommitLine{Kind: ln.Kind, Old: ln.Old, New: ln.New}
				if ln.Kind == "hunk" {
					row.HTML = template.HTML(html.EscapeString(ln.Text))
				} else {
					row.HTML = template.HTML(painter.Line(ln.Text))
				}
				cf.Lines = append(cf.Lines, row)
			}
			cf.Pairs = pairDiff(cf.Lines)
		}
		d.Added += cf.Added
		d.Deleted += cf.Deleted
		d.Files = append(d.Files, cf)
	}
	d.FilesN = len(d.Files)
	d.Tree = commitTree(d.Files)
	return d
}

func pairDiff(lines []CommitLine) []CommitPair {
	var out []CommitPair
	for i := 0; i < len(lines); {
		ln := lines[i]
		if ln.Kind == "hunk" {
			out = append(out, CommitPair{Hunk: html.UnescapeString(string(ln.HTML))})
			i++
			continue
		}
		if ln.Kind == "ctx" {
			out = append(out, CommitPair{
				LKind: "ctx", RKind: "ctx", LNo: ln.Old, RNo: ln.New, LHTML: ln.HTML, RHTML: ln.HTML,
			})
			i++
			continue
		}
		var dels, adds []CommitLine
		for i < len(lines) && lines[i].Kind == "del" {
			dels = append(dels, lines[i])
			i++
		}
		for i < len(lines) && lines[i].Kind == "add" {
			adds = append(adds, lines[i])
			i++
		}
		n := len(dels)
		if len(adds) > n {
			n = len(adds)
		}
		for k := 0; k < n; k++ {
			p := CommitPair{}
			if k < len(dels) {
				p.LKind = "del"
				p.LNo = dels[k].Old
				p.LHTML = dels[k].HTML
			}
			if k < len(adds) {
				p.RKind = "add"
				p.RNo = adds[k].New
				p.RHTML = adds[k].HTML
			}
			out = append(out, p)
		}
	}
	return out
}

func diffAnchor(path string, seen map[string]int) string {
	var b strings.Builder
	b.WriteString("diff-")
	for _, r := range path {
		switch {
		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '_':
			b.WriteRune(r)
		default:
			b.WriteByte('-')
		}
	}
	base := b.String()
	n := seen[base]
	seen[base]++
	if n == 0 {
		return base
	}
	return base + "-" + strconv.Itoa(n)
}

func blobLink(repoPath, rev, path string) string {
	parts := strings.Split(path, "/")
	for i, p := range parts {
		parts[i] = url.PathEscape(p)
	}
	return "/" + repoPath + "/-/blob/" + strings.Join(parts, "/") + "?rev=" + url.QueryEscape(rev)
}

func commitTree(files []CommitFile) []CommitTreeRow {
	root := &treeNode{kids: map[string]*treeNode{}}
	for i := range files {
		f := &files[i]
		parts := strings.Split(f.Path, "/")
		cur := root
		acc := ""
		for j, part := range parts {
			if acc == "" {
				acc = part
			} else {
				acc += "/" + part
			}
			n := cur.kids[part]
			if n == nil {
				n = &treeNode{name: part, path: acc, kids: map[string]*treeNode{}}
				cur.kids[part] = n
				cur.order = append(cur.order, part)
			}
			if j == len(parts)-1 {
				n.file = f
			} else {
				n.dir = true
			}
			cur = n
		}
	}
	var rows []CommitTreeRow
	var walk func(n *treeNode, depth int)
	walk = func(n *treeNode, depth int) {
		names := append([]string(nil), n.order...)
		sort.Slice(names, func(i, j int) bool {
			a, b := n.kids[names[i]], n.kids[names[j]]
			aDir := a.dir && a.file == nil
			bDir := b.dir && b.file == nil
			if aDir != bDir {
				return aDir
			}
			return strings.ToLower(a.name) < strings.ToLower(b.name)
		})
		for _, name := range names {
			child := n.kids[name]
			shown := depth
			if shown > 8 {
				shown = 8
			}
			if child.dir && child.file == nil {
				rows = append(rows, CommitTreeRow{
					Name: child.name, Path: child.path, Dir: true, Depth: shown, Icon: "dir",
				})
				walk(child, depth+1)
				continue
			}
			f := child.file
			rows = append(rows, CommitTreeRow{
				Name: child.name, Path: f.Path, Anchor: f.Anchor, Status: f.Status,
				Depth: shown, Added: f.Added, Deleted: f.Deleted, Icon: fileIcon(child.name, "blob"),
			})
		}
	}
	walk(root, 0)
	return rows
}

type treeNode struct {
	name, path string
	dir        bool
	file       *CommitFile
	kids       map[string]*treeNode
	order      []string
}
