package server

import (
	"bytes"
	"context"
	"database/sql"
	"image/png"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/card"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/store"

	_ "modernc.org/sqlite"
)

func TestLinkPreviews(t *testing.T) {
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	ctx := context.Background()

	jar, _ := cookiejar.New(nil)
	tim := &http.Client{Jar: jar}
	anon := &http.Client{}
	page := read(t, mustGet(t, tim, ts.URL+"/login"))
	page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"widgets"}, "visibility": {"public"},
	}))
	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
	token := between(page, `<p class="code">`, "</p>")
	me, err := st.UserByUsername(ctx, "tim")
	if err != nil {
		t.Fatal(err)
	}

	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@example")
	git(t, work, "config", "user.name", "tim")
	var lines []string
	for i := 1; i <= 25; i++ {
		lines = append(lines, "L"+twoDigits(i)+"-marker")
	}
	writeFile(t, filepath.Join(work, "main.go"), strings.Join(lines, "\n")+"\n")
	writeFile(t, filepath.Join(work, "README.md"), "# Widgets\n\nEen widget die telt.\n\nTweede alinea.\n")
	git(t, work, "add", ".")
	git(t, work, "commit", "-m", "Fix the gate")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/widgets.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")
	sha := strings.TrimSpace(mustGit(t, work, "rev-parse", "HEAD"))

	page = read(t, mustGet(t, tim, ts.URL+"/tim/widgets"))
	read(t, mustPost(t, tim, ts.URL+"/tim/widgets/-/star", url.Values{"csrf": {csrfOf(t, page)}}))

	home := read(t, mustGet(t, anon, ts.URL+"/tim/widgets"))
	blob := socialBlob(home)
	for _, want := range []string{
		"tim/widgets", "Een widget die telt.", "Go", "1 star", "Fix the gate",
		"BlueGit", "summary_large_image", "#1f6feb", "application/json+oembed", "/assets/logo.svg",
	} {
		if !strings.Contains(home, want) {
			t.Fatalf("repo-kaart mist %q\n%s", want, home)
		}
	}
	if strings.Contains(blob, "Tweede alinea") {
		t.Fatal("tweede alinea hoort niet in de kaart")
	}
	img := ts.URL + "/-/card.png?path=" + url.QueryEscape("/tim/widgets")
	first := mustGet(t, anon, img)
	if first.Header.Get("X-Card-Cache") != "miss" || first.Header.Get("Content-Type") != "image/png" {
		t.Fatalf("cache %s type %s", first.Header.Get("X-Card-Cache"), first.Header.Get("Content-Type"))
	}
	png1 := []byte(read(t, first))
	cfgPNG, err := png.DecodeConfig(bytes.NewReader(png1))
	if err != nil || cfgPNG.Width != card.Width || cfgPNG.Height != card.Height {
		t.Fatalf("png %v %v", cfgPNG, err)
	}
	second := mustGet(t, anon, img)
	if second.Header.Get("X-Card-Cache") != "hit" {
		t.Fatalf("tweede keer %s", second.Header.Get("X-Card-Cache"))
	}
	if !bytes.Equal(png1, []byte(read(t, second))) {
		t.Fatal("cache levert andere bytes")
	}

	filePage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/blob/main.go?L=10-12"))
	fileBlob := socialBlob(filePage)
	for _, want := range []string{"main.go", "L10-marker", "L12-marker", "L10-12"} {
		if !strings.Contains(fileBlob, want) {
			t.Fatalf("bestand mist %q\n%s", want, fileBlob)
		}
	}
	if strings.Contains(fileBlob, "L01-marker") || strings.Contains(fileBlob, "L25-marker") {
		t.Fatalf("verkeerde regels:\n%s", fileBlob)
	}
	frag := srv.cardForPath(ctx, "/tim/widgets/-/blob/main.go", "", "#L10-12")
	if !strings.Contains(frag.Description, "L10-marker") || strings.Contains(frag.Description, "L01-marker") {
		t.Fatalf("fragment %q", frag.Description)
	}

	commitPage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/commit/"+sha))
	if !strings.Contains(socialBlob(commitPage), "Fix the gate") {
		t.Fatalf("commit:\n%s", socialBlob(commitPage))
	}

	git(t, work, "checkout", "-b", "feature")
	writeFile(t, filepath.Join(work, "main.go"), "package main\nextra\n")
	git(t, work, "add", "main.go")
	git(t, work, "commit", "-m", "extra regel")
	git(t, work, "push", "-u", "origin", "feature")
	repo, err := st.RepoByPath(ctx, "tim", "widgets")
	if err != nil {
		t.Fatal(err)
	}
	mr, err := st.CreateMergeRequest(ctx, repo.ID, me.ID, "Fix the gate", "Eerste stuk van de merge request.", "feature", "master")
	if err != nil {
		t.Fatal(err)
	}
	pipeID, err := st.CreatePipeline(ctx, repo.ID, sha, "refs/heads/feature", "merge_request", "tim", "Fix the gate", []store.NewJob{{
		Name: "test", Stage: "test", Image: "alpine", Script: "true",
	}})
	if err != nil {
		t.Fatal(err)
	}
	if err := st.AttachPipelineMR(ctx, pipeID, mr.ID); err != nil {
		t.Fatal(err)
	}
	mrPage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/merge-requests/1"))
	mrBlob := socialBlob(mrPage)
	for _, want := range []string{"!1 Fix the gate", "open", "feature → master", "tim", "Eerste stuk", "pending", "&#43;2 −25"} {
		if !strings.Contains(mrBlob, want) {
			t.Fatalf("mr mist %q\n%s", want, mrBlob)
		}
	}

	lab, err := st.UpsertLabel(ctx, repo.ID, "bug", "#428fdc")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateIssue(ctx, repo.ID, me.ID, store.NewIssue{
		Title: "Login fails", Description: "Het formulier weigert.", LabelIDs: []int64{lab.ID},
	}); err != nil {
		t.Fatal(err)
	}
	issuePage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/issues/1"))
	issueBlob := socialBlob(issuePage)
	for _, want := range []string{"#1 Login fails", "open", "bug", "tim", "Het formulier weigert."} {
		if !strings.Contains(issueBlob, want) {
			t.Fatalf("issue mist %q\n%s", want, issueBlob)
		}
	}

	if _, err := st.CreateIssue(ctx, repo.ID, me.ID, store.NewIssue{
		Title: "ZXQCONF", Description: "ZXQCONFBODY", Confidential: true,
	}); err != nil {
		t.Fatal(err)
	}
	secretIssue := read(t, mustGet(t, tim, ts.URL+"/tim/widgets/-/issues/2"))
	if !strings.Contains(secretIssue, "ZXQCONF") {
		t.Fatal("de auteur ziet het issue niet")
	}
	if strings.Contains(socialBlob(secretIssue), "ZXQCONF") || strings.Contains(socialBlob(secretIssue), "ZXQCONFBODY") {
		t.Fatalf("vertrouwelijk lekt in de kaart:\n%s", socialBlob(secretIssue))
	}
	if !strings.Contains(socialBlob(secretIssue), card.LockedTitle) {
		t.Fatal("geen generieke kaart")
	}
	crawl := crawlerGet(t, tim, ts.URL+"/tim/widgets/-/issues/2")
	if crawl.StatusCode != http.StatusOK {
		t.Fatalf("crawler %d", crawl.StatusCode)
	}
	crawlBody := read(t, crawl)
	if strings.Contains(crawlBody, "ZXQCONF") || strings.Contains(crawlBody, "ZXQCONFBODY") || !strings.Contains(crawlBody, card.LockedTitle) {
		t.Fatalf("crawler-issue:\n%s", crawlBody)
	}

	pipePage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/pipelines/"+strconv.FormatInt(pipeID, 10)))
	if !strings.Contains(socialBlob(pipePage), "pending") || !strings.Contains(socialBlob(pipePage), "Fix the gate") {
		t.Fatalf("pipeline:\n%s", socialBlob(pipePage))
	}
	if _, err := st.CreateRelease(ctx, repo.ID, "v1.0.0", sha, "Eerste uitgave", "Een release voor de kaart.", me.ID, 0, nil); err != nil {
		t.Fatal(err)
	}
	relPage := read(t, mustGet(t, anon, ts.URL+"/tim/widgets/-/releases"))
	relBlob := socialBlob(relPage)
	for _, want := range []string{"v1.0.0", "Eerste uitgave", "Een release voor de kaart."} {
		if !strings.Contains(relBlob, want) {
			t.Fatalf("release mist %q\n%s", want, relBlob)
		}
	}

	g, err := st.CreateGroup(ctx, me.ID, "Kaartgroep", "kaartgroep", "Groep voor kaarten", access.RoleDeveloper)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateGroup(ctx, g.ID, "Groep voor kaarten", "public", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateRepo(ctx, "group", g.ID, "publiek", "een repo", "master", "public"); err != nil {
		t.Fatal(err)
	}
	groupPage := read(t, mustGet(t, anon, ts.URL+"/groups/kaartgroep"))
	groupBlob := socialBlob(groupPage)
	for _, want := range []string{"Kaartgroep", "Groep voor kaarten", "1 repository"} {
		if !strings.Contains(groupBlob, want) {
			t.Fatalf("groep mist %q\n%s", want, groupBlob)
		}
	}
	if _, err := st.CreateGroup(ctx, me.ID, "ZXQGROUP", "zxqgroup", "ZXQGROUPBODY", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	hiddenGroup := crawlerGet(t, tim, ts.URL+"/groups/zxqgroup")
	hiddenBody := read(t, hiddenGroup)
	if hiddenGroup.StatusCode != http.StatusOK || strings.Contains(hiddenBody, "ZXQGROUP") || !strings.Contains(hiddenBody, card.LockedTitle) {
		t.Fatalf("groep-crawler %d\n%s", hiddenGroup.StatusCode, hiddenBody)
	}

	userPage := read(t, mustGet(t, anon, ts.URL+"/users/tim"))
	if !strings.Contains(socialBlob(userPage), "tim") || !strings.Contains(socialBlob(userPage), "1 repository") {
		t.Fatalf("gebruiker:\n%s", socialBlob(userPage))
	}

	page = read(t, mustGet(t, tim, ts.URL+"/new"))
	read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"zxqpriv"}, "description": {"ZXQPRIVREADME"}, "visibility": {"private"},
	}))
	privWork := t.TempDir()
	git(t, privWork, "init", "-b", "master")
	git(t, privWork, "config", "user.email", "tim@example")
	git(t, privWork, "config", "user.name", "tim")
	writeFile(t, filepath.Join(privWork, "README.md"), "ZXQPRIVREADME\n")
	git(t, privWork, "add", ".")
	git(t, privWork, "commit", "-m", "geheim")
	privRemote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/zxqpriv.git"
	git(t, privWork, "remote", "add", "origin", privRemote)
	git(t, privWork, "push", "-u", "origin", "master")

	owned := read(t, mustGet(t, tim, ts.URL+"/tim/zxqpriv"))
	if !strings.Contains(owned, "zxqpriv") {
		t.Fatal("eigenaar ziet de repository niet")
	}
	ownedBlob := socialBlob(owned)
	if strings.Contains(ownedBlob, "zxqpriv") || strings.Contains(ownedBlob, "ZXQPRIVREADME") || !strings.Contains(ownedBlob, card.LockedTitle) {
		t.Fatalf("prive-kaart met cookie:\n%s", ownedBlob)
	}
	plain, err := anon.Get(ts.URL + "/tim/zxqpriv")
	if err != nil {
		t.Fatal(err)
	}
	if plain.StatusCode != http.StatusNotFound {
		t.Fatalf("anoniem %d", plain.StatusCode)
	}
	plain.Body.Close()
	bot := crawlerGet(t, anon, ts.URL+"/tim/zxqpriv")
	botBody := read(t, bot)
	if bot.StatusCode != http.StatusOK || strings.Contains(botBody, "zxqpriv") || strings.Contains(botBody, "ZXQPRIVREADME") || !strings.Contains(botBody, card.LockedTitle) {
		t.Fatalf("crawler-prive %d\n%s", bot.StatusCode, botBody)
	}
	lockPNG := []byte(read(t, mustGet(t, tim, ts.URL+"/-/card.png?locked=1")))
	privPNG := []byte(read(t, mustGet(t, tim, ts.URL+"/-/card.png?path="+url.QueryEscape("/tim/zxqpriv"))))
	if !bytes.Equal(lockPNG, privPNG) {
		t.Fatal("prive-afbeelding wijkt af van de generieke kaart")
	}
	confPNG := []byte(read(t, mustGet(t, tim, ts.URL+"/-/card.png?path="+url.QueryEscape("/tim/widgets/-/issues/2"))))
	if !bytes.Equal(lockPNG, confPNG) {
		t.Fatal("vertrouwelijke afbeelding wijkt af")
	}

	if _, err := st.CreateRepo(ctx, "user", me.ID, "zxqint", "ZXQINTBODY", "master", "private"); err != nil {
		t.Fatal(err)
	}
	db, err := sql.Open("sqlite", "file:"+filepath.Join(storage, "bluegit.db")+"?_pragma=busy_timeout(5000)")
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	if _, err := db.Exec(`UPDATE repos SET visibility = 'internal' WHERE name = 'zxqint'`); err != nil {
		t.Fatal(err)
	}
	internalPage := read(t, mustGet(t, tim, ts.URL+"/tim/zxqint"))
	internalBlob := socialBlob(internalPage)
	if strings.Contains(internalBlob, "zxqint") || strings.Contains(internalBlob, "ZXQINTBODY") || !strings.Contains(internalBlob, card.LockedTitle) {
		t.Fatalf("internal:\n%s", internalBlob)
	}
	bot = crawlerGet(t, tim, ts.URL+"/tim/zxqint")
	botBody = read(t, bot)
	if strings.Contains(botBody, "zxqint") || strings.Contains(botBody, "ZXQINTBODY") || !strings.Contains(botBody, card.LockedTitle) {
		t.Fatalf("crawler-internal:\n%s", botBody)
	}

	oem := read(t, mustGet(t, tim, ts.URL+"/api/v1/oembed?url="+url.QueryEscape("http://git.example/tim/widgets")))
	if !strings.Contains(oem, `"provider_name":"BlueGit"`) || !strings.Contains(oem, "tim/widgets") || !strings.Contains(oem, "Een widget die telt.") {
		t.Fatalf("oembed:\n%s", oem)
	}
	oemPriv := read(t, mustGet(t, tim, ts.URL+"/api/v1/oembed?url="+url.QueryEscape("http://git.example/tim/zxqpriv")))
	if strings.Contains(oemPriv, "zxqpriv") || strings.Contains(oemPriv, "ZXQPRIVREADME") || !strings.Contains(oemPriv, card.LockedTitle) {
		t.Fatalf("oembed prive:\n%s", oemPriv)
	}

	info := read(t, mustGet(t, anon, ts.URL+"/-/info"))
	for _, want := range []string{`id="previews"`, "Open Graph", card.LockedTitle, "#L10-20"} {
		if !strings.Contains(info, want) {
			t.Fatalf("info mist %q", want)
		}
	}
}

func twoDigits(n int) string {
	if n < 10 {
		return "0" + string(rune('0'+n))
	}
	return string(rune('0'+n/10)) + string(rune('0'+n%10))
}

func socialBlob(page string) string {
	var b strings.Builder
	for _, key := range []string{"og:title", "og:description", "og:url", "og:image", "og:site_name", "twitter:title", "twitter:description", "twitter:image", "description", "theme-color"} {
		b.WriteString(metaContent(page, "property", key))
		b.WriteString("\n")
		b.WriteString(metaContent(page, "name", key))
		b.WriteString("\n")
	}
	const needle = `application/json+oembed" href="`
	if i := strings.Index(page, needle); i >= 0 {
		rest := page[i+len(needle):]
		if j := strings.Index(rest, `"`); j >= 0 {
			b.WriteString(rest[:j])
		}
	}
	return b.String()
}

func metaContent(page, attr, key string) string {
	tag := attr + `="` + key + `" content="`
	i := strings.Index(page, tag)
	if i < 0 {
		return ""
	}
	rest := page[i+len(tag):]
	j := strings.Index(rest, `"`)
	if j < 0 {
		return ""
	}
	return rest[:j]
}

func crawlerGet(t *testing.T, c *http.Client, raw string) *http.Response {
	t.Helper()
	req, err := http.NewRequest(http.MethodGet, raw, nil)
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; Discordbot/2.0; +https://discordapp.com)")
	res, err := c.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	return res
}
