package server

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"html"
	"image"
	_ "image/gif"
	_ "image/jpeg"
	"image/png"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/card"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func (s *Server) cardCache() *card.Cache {
	if s.cards == nil {
		s.cards = card.NewCache(128)
	}
	return s.cards
}

func (s *Server) absURL(path string) string {
	base := strings.TrimRight(s.Cfg.BaseURL, "/")
	if path == "" {
		path = "/"
	}
	if !strings.HasPrefix(path, "/") {
		path = "/" + path
	}
	return base + path
}

func (s *Server) lockedRender() card.Render {
	return card.Locked(s.absURL("/"), s.absURL("/-/card.png?locked=1"), s.absURL("/api/v1/oembed?locked=1"))
}

// cardForPath bouwt de kaart als anonieme bezoeker. De sessie wordt niet gelezen.
func (s *Server) cardForPath(ctx context.Context, path, rawQuery, fragment string) card.Render {
	path = "/" + strings.Trim(strings.TrimSpace(path), "/")
	if path == "/" {
		return s.siteRender(path, rawQuery)
	}
	page := s.absURL(path)
	if rawQuery != "" {
		page += "?" + rawQuery
	}
	img := s.imageFor(path, rawQuery, fragment)
	oem := s.oembedFor(page)
	if s.Store == nil {
		return card.Site(page, img, oem)
	}
	if strings.HasPrefix(path, "/groups/") {
		return s.groupCard(ctx, strings.TrimPrefix(path, "/groups/"), page, img, oem)
	}
	if strings.HasPrefix(path, "/users/") {
		name := strings.Trim(strings.TrimPrefix(path, "/users/"), "/")
		if i := strings.Index(name, "/"); i >= 0 {
			name = name[:i]
		}
		return s.userCard(ctx, name, page, img, oem)
	}
	parts := strings.Split(strings.Trim(path, "/"), "/")
	if len(parts) < 2 || strings.HasPrefix(parts[0], "-") {
		return card.Site(page, img, oem)
	}
	repo, err := s.Store.RepoByPath(ctx, parts[0], strings.TrimSuffix(parts[1], ".git"))
	if err != nil {
		return card.Site(page, img, oem)
	}
	if repo.Visibility != "public" {
		return s.lockedRender()
	}
	q, _ := url.ParseQuery(rawQuery)
	return s.publicRepoCard(ctx, repo, parts[2:], q, fragment, page, img, oem)
}

func (s *Server) siteRender(path, rawQuery string) card.Render {
	page := s.absURL(path)
	if rawQuery != "" {
		page += "?" + rawQuery
	}
	return card.Site(page, s.imageFor(path, rawQuery, ""), s.oembedFor(page))
}

func (s *Server) imageFor(path, rawQuery, fragment string) string {
	v := url.Values{}
	v.Set("path", path)
	q, _ := url.ParseQuery(rawQuery)
	if l := q.Get("L"); l != "" {
		v.Set("L", l)
	} else if _, _, ok := card.ParseLines(fragment); ok {
		v.Set("L", strings.TrimPrefix(strings.TrimSpace(fragment), "#"))
	}
	if rev := q.Get("rev"); rev != "" {
		v.Set("rev", rev)
	}
	return s.absURL("/-/card.png?" + v.Encode())
}

func (s *Server) oembedFor(page string) string {
	return s.absURL("/api/v1/oembed?url=" + url.QueryEscape(page))
}

func (s *Server) publicRepoCard(ctx context.Context, repo store.Repo, rest []string, q url.Values, fragment, page, img, oem string) card.Render {
	kind := ""
	if len(rest) >= 2 && rest[0] == "-" {
		kind = rest[1]
	}
	switch kind {
	case "blob":
		return s.fileCard(ctx, repo, strings.Join(rest[2:], "/"), q, fragment, page, img, oem)
	case "tree":
		return s.repoCard(ctx, repo, page, img, oem)
	case "commit":
		if len(rest) >= 3 {
			return s.commitCard(ctx, repo, rest[2], page, img, oem)
		}
	case "merge-requests":
		if len(rest) >= 3 && rest[2] != "new" {
			if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil {
				return s.mrCard(ctx, repo, n, page, img, oem)
			}
		}
	case "issues":
		if len(rest) >= 3 {
			if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil && n > 0 {
				return s.issueCard(ctx, repo, n, page, img, oem)
			}
		}
	case "pipelines":
		if len(rest) >= 3 {
			if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil && n > 0 {
				return s.pipeCard(ctx, repo, n, page, img, oem)
			}
		}
	case "releases":
		return s.releaseCard(ctx, repo, page, img, oem)
	}
	return s.repoCard(ctx, repo, page, img, oem)
}

func (s *Server) repoCard(ctx context.Context, repo store.Repo, page, img, oem string) card.Render {
	prose := card.Excerpt(repo.Description, 180)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	rev := repo.DefaultBranch
	if prose == "" && s.StoragePath() != "" {
		if entries, err := gitrepo.Tree(ctx, s.Git, dir, rev, ""); err == nil {
			readme, _ := findDocs(entries)
			if readme != "" {
				if text, binary, err := gitrepo.Blob(ctx, s.Git, dir, rev, readme, 80_000); err == nil && !binary {
					prose = card.Excerpt(text, 180)
				}
			}
		}
	}
	var facts []string
	if lang := s.repoLanguage(ctx, dir, rev); lang != "" {
		facts = append(facts, lang)
	}
	if counts, _, err := s.Store.StarInfo(ctx, 0, []int64{repo.ID}); err == nil {
		facts = append(facts, starLabel(counts[repo.ID]))
	}
	if s.StoragePath() != "" {
		if c, err := gitrepo.LastCommit(ctx, s.Git, dir, rev, ""); err == nil && c.SHA != "" {
			short := c.SHA
			if len(short) > 8 {
				short = short[:8]
			}
			facts = append(facts, short+" "+card.Clip(c.Subject, 72))
		}
	}
	return card.Render{Meta: card.Meta{
		Title: repo.OwnerPath + "/" + repo.Name, Description: prose, URL: page, Image: img, OEmbed: oem,
		Theme: "#1f6feb", Kind: "repository", Facts: facts, Initial: repo.Name,
	}, Avatar: s.avatarForRepo(ctx, repo)}
}

func (s *Server) fileCard(ctx context.Context, repo store.Repo, rel string, q url.Values, fragment, page, img, oem string) card.Render {
	rel, err := cleanRel(rel)
	base := s.repoCard(ctx, repo, page, img, oem)
	if err != nil || rel == "" || s.StoragePath() == "" {
		return base
	}
	rev := safeRev(q.Get("rev"), repo.DefaultBranch)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	text, binary, err := gitrepo.Blob(ctx, s.Git, dir, rev, rel, 80_000)
	name := rel
	if i := strings.LastIndex(rel, "/"); i >= 0 {
		name = rel[i+1:]
	}
	from, to, ranged := lineBounds(q, fragment)
	desc := "Binary file"
	if err == nil && !binary {
		desc = card.Snippet(text, from, to, ranged)
	}
	facts := []string{repo.OwnerPath + "/" + repo.Name}
	if lang := langByName(name); lang != "" {
		facts = append(facts, lang)
	}
	if ranged {
		if from == to {
			facts = append(facts, fmt.Sprintf("L%d", from))
		} else {
			facts = append(facts, fmt.Sprintf("L%d-%d", from, to))
		}
	}
	return card.Render{Meta: card.Meta{
		Title: name, Description: desc, URL: page, Image: img, OEmbed: oem,
		Theme: "#1f6feb", Kind: "file", Facts: facts, Initial: name,
	}, Avatar: base.Avatar}
}

func (s *Server) commitCard(ctx context.Context, repo store.Repo, sha, page, img, oem string) card.Render {
	base := s.repoCard(ctx, repo, page, img, oem)
	if !safeSHA(sha) || s.StoragePath() == "" {
		return base
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	c, err := gitrepo.Show(ctx, s.Git, dir, sha)
	if err != nil {
		return base
	}
	short := c.SHA
	if len(short) > 8 {
		short = short[:8]
	}
	facts := []string{c.Author, short}
	if changes, err := gitrepo.CommitFileChanges(ctx, s.Git, dir, c.SHA); err == nil {
		add, del := 0, 0
		for _, ch := range changes {
			add += ch.Added
			del += ch.Deleted
		}
		facts = append(facts, fmt.Sprintf("+%d −%d", add, del), fmt.Sprintf("%d files", len(changes)))
	}
	return card.Render{Meta: card.Meta{
		Title: card.Clip(c.Subject, 90), Description: card.Excerpt(c.Body, 180), URL: page, Image: img, OEmbed: oem,
		Theme: "#0c3f86", Kind: "commit", Facts: facts, Initial: c.Author,
	}, Avatar: base.Avatar}
}

func (s *Server) mrCard(ctx context.Context, repo store.Repo, number int64, page, img, oem string) card.Render {
	base := s.repoCard(ctx, repo, page, img, oem)
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil {
		return base
	}
	status := mr.Status
	if mr.Draft && status == "open" {
		status = "draft"
	}
	facts := []string{status, mr.SourceBranch + " → " + mr.TargetBranch, mr.Author}
	if s.StoragePath() != "" {
		dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
		if changes, err := gitrepo.CompareChanges(ctx, s.Git, dir, mr.TargetBranch, mr.SourceBranch); err == nil {
			add, del := 0, 0
			for _, ch := range changes {
				add += ch.Added
				del += ch.Deleted
			}
			facts = append(facts, fmt.Sprintf("+%d −%d", add, del))
		}
	}
	if p, err := s.Store.LatestMergePipeline(ctx, repo.ID, mr.ID); err == nil {
		jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
		facts = append(facts, displayStatus(p.Status, jobs))
	}
	theme := "#1f6feb"
	switch status {
	case "merged":
		theme = "#146c43"
	case "closed":
		theme = "#5c6b80"
	}
	return card.Render{Meta: card.Meta{
		Title:       "!" + strconv.FormatInt(mr.Number, 10) + " " + mr.Title,
		Description: card.Excerpt(mr.Description, 180), URL: page, Image: img, OEmbed: oem,
		Theme: theme, Kind: "merge_request", Facts: facts, Initial: mr.Author,
	}, Avatar: base.Avatar}
}

func (s *Server) issueCard(ctx context.Context, repo store.Repo, number int64, page, img, oem string) card.Render {
	iss, err := s.Store.IssueByNumber(ctx, repo.ID, number)
	if err != nil {
		return s.repoCard(ctx, repo, page, img, oem)
	}
	if iss.Confidential {
		return s.lockedRender()
	}
	var labels []string
	for _, l := range iss.Labels {
		labels = append(labels, l.Name)
	}
	facts := []string{iss.Status}
	if len(labels) > 0 {
		facts = append(facts, strings.Join(labels, ", "))
	}
	facts = append(facts, iss.Author)
	return card.Render{Meta: card.Meta{
		Title:       "#" + strconv.FormatInt(iss.Number, 10) + " " + iss.Title,
		Description: card.Excerpt(iss.Description, 180), URL: page, Image: img, OEmbed: oem,
		Theme: "#9a6700", Kind: "issue", Facts: facts, Initial: iss.Author,
	}, Avatar: s.avatarForRepo(ctx, repo)}
}

func (s *Server) pipeCard(ctx context.Context, repo store.Repo, id int64, page, img, oem string) card.Render {
	base := s.repoCard(ctx, repo, page, img, oem)
	p, err := s.Store.PipelineByID(ctx, repo.ID, id)
	if err != nil {
		return base
	}
	jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
	status := displayStatus(p.Status, jobs)
	theme := "#1f6feb"
	switch status {
	case "passed":
		theme = "#146c43"
	case "failed":
		theme = "#9f2d2d"
	case "running":
		theme = "#9a6700"
	}
	facts := []string{status}
	if p.Ref != "" {
		facts = append(facts, strings.TrimPrefix(p.Ref, "refs/heads/"))
	}
	if p.CommitTitle != "" {
		facts = append(facts, card.Clip(p.CommitTitle, 72))
	}
	if p.Actor != "" {
		facts = append(facts, p.Actor)
	}
	return card.Render{Meta: card.Meta{
		Title: "#" + strconv.FormatInt(p.ID, 10) + " " + status, Description: card.Excerpt(p.CommitTitle, 180),
		URL: page, Image: img, OEmbed: oem, Theme: theme, Kind: "pipeline", Facts: facts, Initial: repo.Name,
	}, Avatar: base.Avatar}
}

func (s *Server) releaseCard(ctx context.Context, repo store.Repo, page, img, oem string) card.Render {
	base := s.repoCard(ctx, repo, page, img, oem)
	list, err := s.Store.ListReleases(ctx, repo.ID)
	if err != nil || len(list) == 0 {
		return card.Render{Meta: card.Meta{
			Title: "Releases", Description: repo.OwnerPath + "/" + repo.Name, URL: page, Image: img, OEmbed: oem,
			Theme: "#146c43", Kind: "release", Initial: repo.Name,
		}, Avatar: base.Avatar}
	}
	rel := list[0]
	title := rel.Tag
	if rel.Name != "" {
		title = rel.Tag + " · " + rel.Name
	}
	return card.Render{Meta: card.Meta{
		Title: title, Description: card.Excerpt(rel.Body, 180), URL: page, Image: img, OEmbed: oem,
		Theme: "#146c43", Kind: "release", Facts: []string{repo.OwnerPath + "/" + repo.Name, rel.Tag}, Initial: repo.Name,
	}, Avatar: base.Avatar}
}

func (s *Server) groupCard(ctx context.Context, rest, page, img, oem string) card.Render {
	name := rest
	if i := strings.Index(name, "/"); i >= 0 {
		name = name[:i]
	}
	g, err := s.Store.GroupByPath(ctx, name)
	if err != nil {
		return card.Site(page, img, oem)
	}
	if g.Visibility != "public" {
		return s.lockedRender()
	}
	n, _ := s.Store.CountRepos(ctx, "group", g.ID, true)
	return card.Render{Meta: card.Meta{
		Title: g.Name, Description: card.Excerpt(g.Description, 180), URL: page, Image: img, OEmbed: oem,
		Theme: "#6f42c1", Kind: "group", Facts: []string{repoLabel(n)}, Initial: g.Name,
	}, Avatar: s.readLogo("group", g.ID, g.LogoMIME)}
}

func (s *Server) userCard(ctx context.Context, name, page, img, oem string) card.Render {
	u, err := s.Store.UserByUsername(ctx, name)
	if err != nil {
		return card.Site(page, img, oem)
	}
	n, _ := s.Store.CountRepos(ctx, "user", u.ID, true)
	return card.Render{Meta: card.Meta{
		Title: u.Username, Description: "Public profile", URL: page, Image: img, OEmbed: oem,
		Theme: "#1f6feb", Kind: "user", Facts: []string{repoLabel(n)}, Initial: u.Username,
	}}
}

func (s *Server) avatarForRepo(ctx context.Context, repo store.Repo) []byte {
	if b := s.readLogo("repo", repo.ID, repo.LogoMIME); len(b) > 0 {
		return b
	}
	if repo.OwnerKind != "group" {
		return nil
	}
	g, err := s.Store.GroupByID(ctx, repo.OwnerID)
	if err != nil {
		return nil
	}
	return s.readLogo("group", g.ID, g.LogoMIME)
}

func (s *Server) readLogo(kind string, id int64, mime string) []byte {
	if mime != "image/png" && mime != "image/jpeg" && mime != "image/gif" {
		return nil
	}
	path, err := s.logoPath(kind, id)
	if err != nil {
		return nil
	}
	data, err := os.ReadFile(path)
	if err != nil {
		return nil
	}
	img, _, err := image.Decode(bytes.NewReader(data))
	if err != nil {
		return nil
	}
	var buf bytes.Buffer
	if err := png.Encode(&buf, img); err != nil {
		return nil
	}
	return buf.Bytes()
}

func (s *Server) repoLanguage(ctx context.Context, dir, rev string) string {
	if s.StoragePath() == "" {
		return ""
	}
	entries, err := gitrepo.TreeAll(ctx, s.Git, dir, rev)
	if err != nil {
		return ""
	}
	counts := map[string]int{}
	for _, e := range entries {
		if e.Type != "blob" {
			continue
		}
		if strings.Contains(e.Name, "vendor/") || strings.Contains(e.Name, "node_modules/") {
			continue
		}
		if lang := langByName(e.Name); lang != "" {
			counts[lang]++
		}
	}
	best, n := "", 0
	for lang, c := range counts {
		if c > n || (c == n && lang < best) {
			best, n = lang, c
		}
	}
	return best
}

func langByName(name string) string {
	low := strings.ToLower(name)
	if i := strings.LastIndex(low, "/"); i >= 0 {
		low = low[i+1:]
	}
	ext := ""
	if i := strings.LastIndex(low, "."); i >= 0 {
		ext = low[i:]
	}
	if lang, ok := extLang[ext]; ok {
		return lang
	}
	switch low {
	case "dockerfile":
		return "Dockerfile"
	case "makefile":
		return "Makefile"
	default:
		return ""
	}
}

var extLang = map[string]string{
	".go": "Go", ".py": "Python", ".js": "JavaScript", ".jsx": "JavaScript", ".ts": "TypeScript", ".tsx": "TypeScript",
	".rs": "Rust", ".java": "Java", ".rb": "Ruby", ".php": "PHP", ".c": "C", ".h": "C", ".cpp": "C++", ".cc": "C++",
	".cs": "C#", ".swift": "Swift", ".kt": "Kotlin", ".html": "HTML", ".css": "CSS", ".scss": "SCSS", ".vue": "Vue",
	".sh": "Shell", ".yml": "YAML", ".yaml": "YAML", ".sql": "SQL", ".lua": "Lua",
}

func starLabel(n int) string {
	if n == 1 {
		return "1 star"
	}
	return strconv.Itoa(n) + " stars"
}

func repoLabel(n int) string {
	if n == 1 {
		return "1 repository"
	}
	return strconv.Itoa(n) + " repositories"
}

func lineBounds(q url.Values, fragment string) (from, to int, ok bool) {
	if from, to, ok = card.ParseLines(fragment); ok {
		return from, to, true
	}
	return card.ParseLines(q.Get("L"))
}

func (s *Server) cardPNG(w http.ResponseWriter, r *http.Request) {
	var rend card.Render
	if r.URL.Query().Get("locked") == "1" {
		rend = s.lockedRender()
	} else {
		path := r.URL.Query().Get("path")
		if !strings.HasPrefix(path, "/") || strings.Contains(path, "..") || strings.Contains(path, "\\") {
			http.NotFound(w, r)
			return
		}
		q := url.Values{}
		if l := r.URL.Query().Get("L"); l != "" {
			q.Set("L", l)
		}
		if rev := r.URL.Query().Get("rev"); rev != "" {
			q.Set("rev", rev)
		}
		rend = s.cardForPath(r.Context(), path, q.Encode(), "")
	}
	svg := card.SVG(rend)
	pngBytes, hit := s.cardCache().Get(svg)
	if !hit {
		var err error
		pngBytes, err = card.Raster(svg)
		if err != nil {
			http.Error(w, "card", http.StatusInternalServerError)
			return
		}
		s.cardCache().Put(svg, pngBytes)
	}
	w.Header().Set("Content-Type", "image/png")
	w.Header().Set("Cache-Control", "public, max-age=300")
	w.Header().Set("X-Content-Type-Options", "nosniff")
	if hit {
		w.Header().Set("X-Card-Cache", "hit")
	} else {
		w.Header().Set("X-Card-Cache", "miss")
	}
	_, _ = w.Write(pngBytes)
}

func (s *Server) oembed(w http.ResponseWriter, r *http.Request) {
	var rend card.Render
	if r.URL.Query().Get("locked") == "1" {
		rend = s.lockedRender()
	} else {
		raw := r.URL.Query().Get("url")
		u, err := url.Parse(raw)
		if err != nil || u.Path == "" {
			http.NotFound(w, r)
			return
		}
		rend = s.cardForPath(r.Context(), u.Path, u.RawQuery, u.Fragment)
	}
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	_ = json.NewEncoder(w).Encode(map[string]any{
		"version":          "1.0",
		"type":             "link",
		"title":            rend.Title,
		"description":      rend.Blurb(),
		"provider_name":    "BlueGit",
		"provider_url":     s.absURL("/"),
		"thumbnail_url":    rend.Image,
		"thumbnail_width":  card.Width,
		"thumbnail_height": card.Height,
	})
}

func (s *Server) writeLockedCard(w http.ResponseWriter, r *http.Request) {
	m := s.lockedRender().Meta
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	w.Header().Set("X-Robots-Tag", "noindex")
	w.WriteHeader(http.StatusOK)
	title := html.EscapeString(m.Title)
	fmt.Fprintf(w, `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>%s</title>%s<link rel="icon" href="/assets/logo.svg" type="image/svg+xml"></head><body><p>%s</p></body></html>`,
		title, metaHTML(m), title)
}

func metaHTML(m card.Meta) string {
	esc := html.EscapeString
	var b strings.Builder
	fmt.Fprintf(&b, `<meta name="theme-color" content="%s">`, esc(m.Theme))
	fmt.Fprintf(&b, `<meta name="description" content="%s">`, esc(m.Blurb()))
	b.WriteString(`<meta property="og:site_name" content="BlueGit">`)
	b.WriteString(`<meta property="og:type" content="website">`)
	fmt.Fprintf(&b, `<meta property="og:title" content="%s">`, esc(m.Title))
	fmt.Fprintf(&b, `<meta property="og:description" content="%s">`, esc(m.Blurb()))
	fmt.Fprintf(&b, `<meta property="og:url" content="%s">`, esc(m.URL))
	fmt.Fprintf(&b, `<meta property="og:image" content="%s">`, esc(m.Image))
	b.WriteString(`<meta property="og:image:type" content="image/png">`)
	fmt.Fprintf(&b, `<meta property="og:image:width" content="%d">`, card.Width)
	fmt.Fprintf(&b, `<meta property="og:image:height" content="%d">`, card.Height)
	b.WriteString(`<meta name="twitter:card" content="summary_large_image">`)
	fmt.Fprintf(&b, `<meta name="twitter:title" content="%s">`, esc(m.Title))
	fmt.Fprintf(&b, `<meta name="twitter:description" content="%s">`, esc(m.Blurb()))
	fmt.Fprintf(&b, `<meta name="twitter:image" content="%s">`, esc(m.Image))
	fmt.Fprintf(&b, `<link rel="alternate" type="application/json+oembed" href="%s" title="BlueGit">`, esc(m.OEmbed))
	return b.String()
}

func isCrawler(r *http.Request) bool {
	ua := strings.ToLower(r.Header.Get("User-Agent"))
	for _, name := range []string{
		"discordbot", "slackbot", "twitterbot", "facebookexternalhit", "linkedinbot",
		"telegrambot", "whatsapp", "embedly", "iframely", "redditbot", "pinterestbot",
		"skypeuripreview",
	} {
		if strings.Contains(ua, name) {
			return true
		}
	}
	return false
}
