package main

import (
	"bytes"
	"fmt"
	"html/template"
	"io"
	"log"
	"math"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"time"

	"github.com/libgit2/git2go"
	"github.com/russross/blackfriday"

	"github.com/heyLu/quit/perf"
)

var performance = perf.NewPerf()

func main() {
	repoPath := "."
	if len(os.Args) > 1 {
		repoPath = os.Args[1]
	}
	var err error
	repoPath, err = filepath.Abs(repoPath)
	if err != nil {
		log.Fatal("getting absolute path: ", err)
	}

	repo, err := git.OpenRepository(repoPath)
	if err != nil {
		log.Fatal("opening repository: ", err)
	}

	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		performance.MeasureRequest(req)

		handleError := func(w http.ResponseWriter, err error) {
			log.Println("git: ", err)
			http.Error(w, "internal server error", http.StatusInternalServerError)
		}

		fancyRepo := NewFancyRepo(repo)
		commit, err := fancyRepo.Commit()
		if err != nil {
			handleError(w, err)
			return
		}
		files, err := commit.Files(false)
		if err != nil {
			handleError(w, err)
			return
		}

		var wg sync.WaitGroup
		wg.Add(len(files))
		for _, f := range files {
			go func(f *FancyFile) {
				defer wg.Done()

				_, err := f.Commit()
				if err != nil {
					handleError(w, err)
				}
			}(f)
		}

		wg.Add(2)
		go func() {
			defer wg.Done()
			_, err := fancyRepo.CommitCount()
			if err != nil {
				handleError(w, err)
			}
		}()
		go func() {
			defer wg.Done()
			_, err := fancyRepo.Contributors()
			if err != nil {
				handleError(w, err)
			}
		}()
		wg.Wait()

		buf := new(bytes.Buffer)
		start := time.Now()
		err = repoTmpl.Execute(buf, map[string]interface{}{
			"RepoPath":    path.Base(repoPath),
			"Repo":        fancyRepo,
			"Style":       template.CSS(repoStyle),
			"Performance": performance.Render(req),
		})
		performance.Measure(req, "template", time.Since(start).String())
		if err != nil {
			log.Println("rendering repo: ", err)
			http.Error(w, "internal server error", http.StatusInternalServerError)
			return
		}
		io.Copy(w, buf)
	})
	http.Handle("/__performance__/", performance)

	log.Fatal(http.ListenAndServe("localhost:12345", nil))
}

type FancyRepo struct {
	repo          *git.Repository
	commit        *FancyCommit
	commitCount   int
	branches      []*git.Branch
	contributors  []*git.Signature
	languageStats *LanguageStats
}

func NewFancyRepo(repo *git.Repository) *FancyRepo {
	return &FancyRepo{repo: repo, commitCount: -1}
}

func (fr *FancyRepo) Commit() (*FancyCommit, error) {
	if fr.commit == nil {
		head, err := fr.repo.Head()
		if err != nil {
			return nil, err
		}

		commit, err := fr.repo.LookupCommit(head.Target())
		if err != nil {
			return nil, err
		}

		fr.commit = NewFancyCommit(commit)
	}
	return fr.commit, nil
}

func (fr *FancyRepo) CommitCount() (int, error) {
	if fr.commitCount < 0 {
		walk, err := fr.repo.Walk()
		if err != nil {
			return -1, err
		}

		head, err := fr.repo.Head()
		if err != nil {
			return -1, err
		}

		err = walk.Push(head.Target())
		if err != nil {
			return -1, err
		}

		c := 0
		err = walk.Iterate(func(commit *git.Commit) bool {
			c += 1
			return true
		})
		if err != nil {
			return -1, err
		}

		fr.commitCount = c
	}
	return fr.commitCount, nil
}

func (fr *FancyRepo) Contributors() ([]*git.Signature, error) {
	if fr.contributors == nil {
		walk, err := fr.repo.Walk()
		if err != nil {
			return nil, err
		}

		head, err := fr.repo.Head()
		if err != nil {
			return nil, err
		}

		err = walk.Push(head.Target())
		if err != nil {
			return nil, err
		}

		authors := make(map[string]*git.Signature)
		err = walk.Iterate(func(commit *git.Commit) bool {
			authors[commit.Author().Name] = commit.Author()
			return true
		})
		if err != nil {
			return nil, err
		}

		for _, author := range authors {
			fr.contributors = append(fr.contributors, author)
		}
	}
	return fr.contributors, nil
}

func (fr *FancyRepo) Branches() ([]*git.Branch, error) {
	if fr.branches == nil {
		it, err := fr.repo.NewBranchIterator(git.BranchRemote)
		if err != nil {
			return nil, err
		}

		err = it.ForEach(func(b *git.Branch, bt git.BranchType) error {
			fr.branches = append(fr.branches, b)
			return nil
		})
		if err != nil {
			return nil, err
		}
	}
	return fr.branches, nil
}

func (fr *FancyRepo) Tags() ([]string, error) {
	return fr.repo.Tags.List()
}

var languageSuffixes = map[string]string{
	".c":             "C",
	".h":             "C",
	".cpp":           "C++",
	"CMakeLists.txt": "CMake",
	".cmake":         "CMake",
	".css":           "CSS",
	".go":            "Go",
	".html":          "HTML",
	".js":            "JavaScript",
	".java":          "Java",
	"Makefile":       "Makefile",
	".py":            "Python",
	".rb":            "Ruby",
	".rs":            "Rust",
	".sh":            "Shell",
	".bash":          "Shell",
}

var languageColors = map[string]string{
	"C":   "#555555",
	"C++": "#f34b7d",
	//"CMake": "",
	"CSS":        "#563d7c",
	"Go":         "#375eab",
	"HTML":       "#e34c26",
	"JavaScript": "#f1e05a",
	"Java":       "#b07219",
	"Makefile":   "#427819",
	"Python":     "#3572A5",
	"Ruby":       "#701516",
	"Rust":       "#dea584",
	"Shell":      "#89e051",
}

func fileToLanguage(filename string) string {
	filename = strings.ToLower(filename)
	for suffix, lang := range languageSuffixes {
		if strings.HasSuffix(filename, suffix) {
			return lang
		}
	}
	return ""
}

type LanguageStats struct {
	percentages map[string]float64
	Languages   []*LanguageInfo
}

type LanguageInfo struct {
	Language   string
	Percentage float64
}

func (li *LanguageInfo) String() string {
	return fmt.Sprintf("%s (%.2f%%)", li.Language, li.Percentage)
}

type languageByPercent []*LanguageInfo

func (l languageByPercent) Len() int           { return len(l) }
func (l languageByPercent) Less(i, j int) bool { return l[i].Percentage < l[j].Percentage }
func (l languageByPercent) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }

func NewLanguageStats(percentages map[string]float64) *LanguageStats {
	for lang, percentage := range percentages {
		if percentage < 0.001 {
			delete(percentages, lang)
			continue
		}

		percentage = math.Trunc(percentage*10000) / 100
		percentages[lang] = percentage
	}

	languages := make([]*LanguageInfo, 0, len(percentages))
	for lang, percentage := range percentages {
		languages = append(languages, &LanguageInfo{Language: lang, Percentage: percentage})
	}
	sort.Sort(sort.Reverse(languageByPercent(languages)))

	return &LanguageStats{
		percentages: percentages,
		Languages:   languages,
	}
}

func (li *LanguageStats) String() string {
	return fmt.Sprintf("%v", li.percentages)
}

func (fr *FancyRepo) LanguageStats() (*LanguageStats, error) {
	if fr.languageStats == nil {
		commit, err := fr.Commit()
		if err != nil {
			return nil, err
		}

		files, err := commit.Files(true)
		if err != nil {
			return nil, err
		}

		total := 0
		languages := make(map[string]int)
		for _, f := range files {
			if f.entry.Type != git.ObjectBlob {
				continue
			}

			lang := fileToLanguage(f.Name())
			if lang == "" {
				continue
			}
			total += 1
			languages[lang] += 1

		}

		percentages := make(map[string]float64)
		for lang, count := range languages {
			percentages[lang] = float64(count) / float64(total)
		}
		fr.languageStats = NewLanguageStats(percentages)
	}
	return fr.languageStats, nil
}

type FancyCommit struct {
	commit     *git.Commit
	files      []*FancyFile
	filesCache map[string]*FancyFile
}

func NewFancyCommit(commit *git.Commit) *FancyCommit {
	return &FancyCommit{
		commit:     commit,
		filesCache: make(map[string]*FancyFile),
	}
}

func (fc *FancyCommit) Author() string {
	return fc.commit.Author().Name
}

func (fc *FancyCommit) Date() *FancyTime {
	return &FancyTime{fc.commit.Author().When}
}

type FancyTime struct {
	time.Time
}

func (fc FancyTime) PrettyString() string {
	makeForm := func(c int, singular, plural string) string {
		form := plural
		if c == 1 {
			form = singular
		}
		return fmt.Sprintf("%d %s ago", c, form)
	}
	now := time.Now()
	diff := time.Since(fc.Time)
	switch {
	case diff < time.Minute:
		return makeForm(int(diff/time.Second), "second", "seconds")
	case diff < time.Hour:
		return makeForm(int(diff/time.Minute), "minute", "minutes")
	case now.AddDate(0, 0, -1).Before(fc.Time):
		return makeForm(int(diff/time.Hour), "hour", "hours")
	case now.AddDate(0, 0, -7).Before(fc.Time):
		d := now.Day() - fc.Time.Day()
		if d <= 0 {
			d += 30
		}
		return makeForm(d, "day", "days")
	case now.AddDate(0, -1, 0).Before(fc.Time):
		d := now.Day() - fc.Time.Day()
		if d <= 0 {
			d += 30
		}
		return makeForm(d/7, "week", "weeks")
	case now.AddDate(-1, 0, 0).Before(fc.Time):
		m := now.Month() - fc.Time.Month()
		if m <= 0 {
			m += 12
		}
		return makeForm(int(m), "month", "months")
	default:
		return makeForm(now.Year()-fc.Time.Year(), "year", "years")
	}
}

func (fc *FancyCommit) Id(n int) string {
	if n == 0 {
		return fc.commit.TreeId().String()
	}
	return fc.commit.TreeId().String()[:n]
}

func (fc *FancyCommit) Summary() string {
	return fc.commit.Summary()
}

func (fc *FancyCommit) Description() string {
	return fc.commit.Message()
}

type byTypeAndName []*FancyFile

func (b byTypeAndName) Len() int           { return len(b) }
func (b byTypeAndName) Less(i, j int) bool { return b[i].Less(b[j]) }
func (b byTypeAndName) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }

func (fc *FancyCommit) Files(recursive bool) ([]*FancyFile, error) {
	if recursive || fc.files == nil {
		tree, err := fc.commit.Tree()
		if err != nil {
			return nil, err
		}

		recurse := 1
		if recursive {
			recurse = 0
		}
		files := make([]*FancyFile, 0)
		err = tree.Walk(func(s string, entry *git.TreeEntry) int {
			files = append(files, NewFancyFile(fc.commit.Owner(), entry))
			return recurse
		})
		if err != nil {
			return nil, err
		}

		sort.Sort(byTypeAndName(files))

		if recursive {
			return files, nil
		}
		fc.files = files
	}
	return fc.files, nil
}

var readmeNames = []string{"README.md", "readme.md", "README.rst", "readme.rst", "README.txt", "readme.txt", "README"}

func (fc *FancyCommit) Readme() (*FancyFile, error) {
	readme := fc.filesCache["|||README|||"]
	if readme == nil {
		tree, err := fc.commit.Tree()
		if err != nil {
			return nil, err
		}

		var entry *git.TreeEntry
		for _, n := range readmeNames {
			entry, err = tree.EntryByPath(n)
			if err == nil {
				break
			}
		}

		if entry == nil {
			return nil, nil
		}

		readme = NewFancyFile(fc.commit.Owner(), entry)
		fc.filesCache["|||README|||"] = readme
	}
	return readme, nil
}

type FancyFile struct {
	repo   *git.Repository
	entry  *git.TreeEntry
	commit *FancyCommit
}

func NewFancyFile(repo *git.Repository, entry *git.TreeEntry) *FancyFile {
	return &FancyFile{repo: repo, entry: entry}
}

func (fc *FancyFile) Name() string {
	return fc.entry.Name
}

func (fc *FancyFile) Commit() (*FancyCommit, error) {
	if fc.commit == nil {
		walk, err := fc.repo.Walk()
		if err != nil {
			return nil, err
		}

		err = walk.PushHead()
		if err != nil {
			return nil, err
		}

		opts, err := git.DefaultDiffOptions()
		if err != nil {
			return nil, err
		}
		opts.Pathspec = []string{fc.entry.Name}

		var lastCommit *git.Commit
		var findErr error
		c := 0
		err = walk.Iterate(func(commit *git.Commit) bool {
			c += 1

			if commit.ParentCount() <= 0 {
				lastCommit = commit
				return false
			}
			tree, err := commit.Tree()
			if err != nil {
				findErr = err
				return false
			}

			matchesAll := true
			for i := uint(0); i < commit.ParentCount(); i++ {
				parentCommit := commit.Parent(i)
				parentTree, err := parentCommit.Tree()
				if err != nil {
					findErr = err
					return false
				}

				diff, err := fc.repo.DiffTreeToTree(parentTree, tree, &opts)
				if err != nil {
					findErr = err
					return false
				}

				n, err := diff.NumDeltas()
				if err != nil {
					findErr = err
					return false
				}

				matchesAll = matchesAll && n > 0
			}

			if !matchesAll {
				return true
			}

			lastCommit = commit
			return false
		})
		if err != nil {
			return nil, err
		}

		if findErr != nil {
			return nil, err
		}

		if lastCommit == nil {
			return nil, fmt.Errorf("did not find commit for %q", fc.entry.Name)
		}

		fc.commit = NewFancyCommit(lastCommit)
	}
	return fc.commit, nil
}

func (fc *FancyFile) Type() string {
	return strings.ToLower(fc.entry.Type.String())
}

func (fc *FancyFile) RawContents() (string, error) {
	blob, err := fc.repo.LookupBlob(fc.entry.Id)
	if err != nil {
		return "", err
	}

	return string(blob.Contents()), nil
}

func (fc *FancyFile) Contents() (template.HTML, error) {
	blob, err := fc.repo.LookupBlob(fc.entry.Id)
	if err != nil {
		return "", err
	}

	buf := new(bytes.Buffer)
	contents := blob.Contents()
	if strings.HasSuffix(fc.entry.Name, ".md") {
		buf.Write(blackfriday.MarkdownCommon(contents))
	} else {
		buf.WriteString("<code><pre>")
		template.HTMLEscape(buf, contents)
		buf.WriteString("</pre></code>")
	}

	return template.HTML(buf.String()), nil
}

func (fc *FancyFile) Less(file *FancyFile) bool {
	if fc.entry.Type == file.entry.Type {
		return fc.entry.Name < file.entry.Name
	}

	return fc.entry.Type < file.entry.Type

}

var repoFuncs = template.FuncMap{
	"count": func(count int, singular, plural string) template.HTML {
		form := plural
		if count == 1 {
			form = singular
		}
		return template.HTML(fmt.Sprintf("<span class=\"count\">%d</span> %s", count, form))
	},
	"languageToColor": func(l string) string {
		c, ok := languageColors[l]
		if !ok {
			return "black"
		}
		return c
	},
}
var repoTmpl = template.Must(template.New("").Funcs(repoFuncs).Parse(`<!doctype html>
<html>
	<head>
		<meta charset="utf-8" />
		<title>{{ .RepoPath }}</title>
		<style>{{ .Style }}</style>
	</head>

	<body>
		<section id="performance-bar"></section>

		<div id="container">

		<section id="repo" class="repo-info">
			<a id="commits" class="repo-stat" href="#"><span class="icon">⏲</span>{{ count .Repo.CommitCount "commit" "commits" }}</a>
			<a id="branches" class="repo-stat" href="#"><span class="icon">⛗</span>{{ count (len .Repo.Branches) "branch" "branches" }}</a>
			<a id="tags" class="repo-stat" href="#"><span class="icon">🏷&#xFE0E;</span>{{ count (len .Repo.Tags) "tag" "tags" }}</a>
			<a id="contributors" class="repo-stat" href="#"><span class="icon">👥</span>{{ count (len .Repo.Contributors) "contributor" "contributors" }}</a>
		</section>

		<div id="languages">
			<ol class="language-list">
			{{ range $language := .Repo.LanguageStats.Languages }}
				<li>
					<span class="language">{{ $language.Language }}</span>
					<span class="percentage">{{ $language.Percentage }}%</span>
				</li>
			{{ end }}
			</ol>

			<div id="language-bar">
			{{ range $language := .Repo.LanguageStats.Languages }}
				<span class="language" title="{{ $language }}" style="width: {{ $language.Percentage }}%; background-color: {{ languageToColor $language.Language }}"><!--{{ $language.Language }}--></span>
			{{ end }}
			</div>
		</div>

		<section id="commit" class="commit-info">
			<div class="commit-author">{{ .Repo.Commit.Author }}</div>
			<div class="commit-summary" title="{{ .Repo.Commit.Description }}">{{ .Repo.Commit.Summary }}</div>
			<div class="commit-id" data-commit="{{ .Repo.Commit.Id 0 }}"><a href="#">{{ .Repo.Commit.Id 10 }}</a></div>
			<time class="commit-date" title="{{ .Repo.Commit.Date }}">{{ .Repo.Commit.Date.PrettyString }}</time>
		</section>

		<table id="files">
			{{ range $file := .Repo.Commit.Files false }}
			<tr class="file">
				<td class="file-name file-type-{{ $file.Type }}">{{ $file.Name }}</td>
				<td class="file-commit" title="{{ $file.Commit.Description }}">{{ $file.Commit.Summary }}</td>
				<td class="file-date" title="{{ $file.Commit.Date }}">{{ $file.Commit.Date.PrettyString }}</td>
			</tr>
			{{ end }}
		</table>

		{{ if .Repo.Commit.Readme }}
		<section id="file" class="readme">
			<h1 class="file-name">{{ .Repo.Commit.Readme.Name }}</h1>
			<div class="contents">
				{{ .Repo.Commit.Readme.Contents }}
			</div>
		</section>
		{{ end }}

		</div>

		{{ .Performance }}
	</body>
</html>
`))

var repoStyle = `
* {
  box-sizing: border-box;
}

body {
  font-family: Arial, sans-serif;
}

#container {
	width: 70vw;
	margin: 0 auto;
}

#repo {
	display: flex;
	justify-content: center;
	border: 1px solid #ddd;
	border-radius: 3px;
	padding: 0.75em;
	margin-bottom: 1em
}

#repo .repo-stat {
	margin-right: 1em;

	color: black;
	text-decoration: none;
}

#repo .repo-stat:hover {
	color: #ad56a0;
}

#repo .repo-stat:hover .icon {
	color: black;
}

#repo .repo-stat .count {
	font-weight: 600;
}

#repo .icon {
	padding-right: 0.2em;
}

.language-list {
  display: none;
}

#language-bar {
  display: flex;
  height: 0.5em;
  margin: -1em 0 1em;
}

#commit {
  display: flex;
  justify-content: space-between;
  align-items: baseline;
  padding: 0.6em 0.5em;
  background-color: hsla(300, 70%, 80%, 0.2);
  border: 1px solid rgba(200, 0, 255, 0.15);
  border-radius: 3px;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
}

#commit .commit-author {
  font-weight: 600;
}

#commit .commit-id {
  font-family: monospace;
}

#files td {
  border: 1px solid rgba(200, 0, 200, 0.15);
  border-radius: 3px;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
  padding: 0.2em 0.5em;
  font-size: 95%;
}

#files tr:hover {
  background-color: #efefef;
}

#files {
  width: 70vw;
  border-collapse: collapse;
  margin-top: -1px;
}

#files .file-name {
  color: #ad56a0;
}

.file-type-blob:before {
  content:"🖹";
  padding-right: 0.5em;
}

.file-type-tree:before {
  content: "🗀";
  padding-right: 0.2em;
}

.file-type-tree:after {
  content: "/";
}

#file .file-name {
  font-size: 90%;
  padding: 0.5em;
  margin-bottom: -1px;
  background-color: hsla(300, 70%, 80%, 0.2);
  border: 1px solid #fbd3f5;
  border-radius: 3px;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
}

#file .contents {
  border: 1px solid #fbd3f5;
  padding: 0.5em 3em;
}

#file .contents > h1 {
  border-bottom: 1px solid #ddd;
  padding-bottom: 0.5em;
}
`