package server

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"path/filepath"
	"strings"
	"testing"
	"time"

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

func TestProfilePage(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://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	cfg.Auth.BaseURL = "https://auth.timfalken.com"
	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)
	srv.Cfg.BaseURL = ts.URL

	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	ctx := context.Background()
	tim, err := st.UserByUsername(ctx, "tim")
	if err != nil {
		t.Fatal(err)
	}
	ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	plein, err := st.CreateGroup(ctx, tim.ID, "Plein", "plein", "open plein", access.RoleDeveloper)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateGroup(ctx, plein.ID, "open plein", "public", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	if err := st.SetLogoMIME(ctx, "group", plein.ID, "image/png"); err != nil {
		t.Fatal(err)
	}
	kluis, err := st.CreateGroup(ctx, tim.ID, "Kluis", "kluis", "dichte kluis", access.RoleDeveloper)
	if err != nil {
		t.Fatal(err)
	}
	zichtbaar, err := st.CreateRepo(ctx, "user", tim.ID, "zichtbaar", "Zichtbare repo", "master", "public")
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetLogoMIME(ctx, "repo", zichtbaar.ID, "image/png"); err != nil {
		t.Fatal(err)
	}
	geheim, err := st.CreateRepo(ctx, "user", tim.ID, "geheim", "Geheim project", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateRepo(ctx, "group", plein.ID, "gedeeld", "Groepsrepo", "master", "public"); err != nil {
		t.Fatal(err)
	}
	if err := st.AddContributions(ctx, []store.Contribution{
		{UserID: tim.ID, RepoID: zichtbaar.ID, Kind: "commit", Ref: "pub", At: time.Now()},
		{UserID: tim.ID, RepoID: geheim.ID, Kind: "commit", Ref: "priv", At: time.Now()},
	}); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repoID(t, st, "tim", "geheim"), "ada", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "group", kluis.ID, "ada", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}

	share := ts.URL + "/users/tim"
	res, err = client.Get(ts.URL + "/")
	if err != nil {
		t.Fatal(err)
	}
	dash := read(t, res)
	for _, want := range []string{
		`class="usercard panel"`,
		`<h2>tim</h2>`,
		`@tim`,
		`data-copy="` + share + `"`,
		`href="/settings">Edit profile`,
		`href="/users/tim"`,
		`<strong>2</strong> <span>Repositories</span>`,
		`<strong>2</strong> <span>Groups</span>`,
		"plein/gedeeld",
		"Activity",
	} {
		if !strings.Contains(dash, want) {
			t.Fatalf("dashboard mist %q", want)
		}
	}
	if strings.Index(dash, "Activity") > strings.Index(dash, "Repositories</span></h2>") {
		t.Fatal("heatmap staat onder de repositorylijst")
	}

	anon := &http.Client{}
	res, err = anon.Get(share)
	if err != nil {
		t.Fatal(err)
	}
	pub := read(t, res)
	for _, want := range []string{
		"<h1>tim</h1>",
		`@tim`,
		"Member since",
		`data-copy="` + share + `"`,
		`src="/tim/zichtbaar/-/logo"`,
		`href="/tim/zichtbaar"`,
		"Zichtbare repo",
		`src="/groups/plein/logo"`,
		`href="/groups/plein"`,
		`<strong>1</strong> <span>Repositories</span>`,
		`<strong>1</strong> <span>Groups</span>`,
		`<strong>1</strong> <span>Contributions</span>`,
		`class="repoacts"`,
		`data-copy="` + ts.URL + `/tim/zichtbaar"`,
		`class="starbtn"`,
	} {
		if !strings.Contains(pub, want) {
			t.Fatalf("openbaar profiel mist %q", want)
		}
	}
	if strings.Contains(pub, `action="/tim/zichtbaar/-/star"`) {
		t.Fatal("anonieme bezoeker krijgt een ster-formulier")
	}
	for _, ban := range []string{"geheim", "Geheim project", "kluis", "Kluis", "Edit profile", "plein/gedeeld"} {
		if strings.Contains(pub, ban) {
			t.Fatalf("openbaar profiel toont %q", ban)
		}
	}

	adaJar, _ := cookiejar.New(nil)
	adaClient := &http.Client{Jar: adaJar}
	sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	u, _ := url.Parse(ts.URL)
	adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	res, err = adaClient.Get(share)
	if err != nil {
		t.Fatal(err)
	}
	adaPage := read(t, res)
	for _, want := range []string{
		`href="/tim/geheim"`,
		"Geheim project",
		`href="/groups/kluis"`,
		`<strong>2</strong> <span>Repositories</span>`,
		`<strong>2</strong> <span>Groups</span>`,
		`<strong>2</strong> <span>Contributions</span>`,
	} {
		if !strings.Contains(adaPage, want) {
			t.Fatalf("ada ziet niet %q", want)
		}
	}
	if strings.Contains(adaPage, "Edit profile") || strings.Contains(adaPage, "plein/gedeeld") {
		t.Fatal("ada ziet Tims bewerkknop of een groepsrepository")
	}

	res, err = client.Get(ts.URL + "/settings")
	if err != nil {
		t.Fatal(err)
	}
	settings := read(t, res)
	if !strings.Contains(settings, "Display name") || !strings.Contains(settings, "Bio") {
		t.Fatal("instellingen missen weergavenaam of bio")
	}
	res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
		"csrf": {csrfOf(t, settings)}, "name": {"Regel\neen"}, "bio": {"nee"},
	})
	if err != nil {
		t.Fatal(err)
	}
	bad := read(t, res)
	if !strings.Contains(bad, "line break") {
		t.Fatalf("ongeldige naam:\n%s", bad)
	}
	res, err = client.PostForm(ts.URL+"/settings/profile", url.Values{
		"csrf": {csrfOf(t, bad)}, "name": {"Tim Falken"}, "bio": {"Bouwt BlueGit."},
	})
	if err != nil {
		t.Fatal(err)
	}
	saved := read(t, res)
	if !strings.Contains(saved, "Profile saved") || !strings.Contains(saved, `value="Tim Falken"`) {
		t.Fatalf("profiel opslaan:\n%s", saved)
	}
	res, err = client.Get(share)
	if err != nil {
		t.Fatal(err)
	}
	named := read(t, res)
	for _, want := range []string{"<h1>Tim Falken</h1>", "@tim", "Bouwt BlueGit.", "Edit profile"} {
		if !strings.Contains(named, want) {
			t.Fatalf("profiel na opslaan mist %q", want)
		}
	}

	timToken, err := st.CreateToken(ctx, tim.ID, "tim")
	if err != nil {
		t.Fatal(err)
	}
	adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
	if err != nil {
		t.Fatal(err)
	}
	mine := apiGet(t, ts.URL+"/api/v1/users/tim", timToken)
	if mine["name"] != "Tim Falken" || mine["bio"] != "Bouwt BlueGit." || mine["web_url"] != share {
		t.Fatalf("api zelf: %#v", mine)
	}
	if mine["instance_admin"] != true || mine["language"] != "en" {
		t.Fatalf("api zelf mist eigen velden: %#v", mine)
	}
	counts := mine["counts"].(map[string]any)
	if counts["repos"] != 2.0 || counts["groups"] != 2.0 || counts["contributions"] != 2.0 {
		t.Fatalf("api tellingen: %#v", counts)
	}
	if !apiPaths(mine["repos"]).has("tim/zichtbaar", "tim/geheim") || apiPaths(mine["repos"]).has("plein/gedeeld") {
		t.Fatalf("api repos: %#v", mine["repos"])
	}
	if !apiPaths(mine["groups"]).has("plein", "kluis") {
		t.Fatalf("api groepen: %#v", mine["groups"])
	}
	other := apiGet(t, ts.URL+"/api/v1/users/tim", adaToken)
	if _, ok := other["instance_admin"]; ok || other["language"] != nil {
		t.Fatalf("api van ada toont Tims privévelden: %#v", other)
	}
	if !apiPaths(other["repos"]).has("tim/geheim") || !apiPaths(other["groups"]).has("kluis") {
		t.Fatalf("api van ada mist privé: %#v %#v", other["repos"], other["groups"])
	}
	if other["counts"].(map[string]any)["contributions"] != 2.0 {
		t.Fatalf("api van ada telt verborgen bijdragen niet mee: %#v", other["counts"])
	}
	pubAPI := apiGet(t, ts.URL+"/api/v1/users/tim", "")
	if _, ok := pubAPI["instance_admin"]; ok || pubAPI["language"] != nil {
		t.Fatalf("anonieme api toont privévelden: %#v", pubAPI)
	}
	if apiPaths(pubAPI["repos"]).has("tim/geheim") || apiPaths(pubAPI["groups"]).has("kluis") || !apiPaths(pubAPI["repos"]).has("tim/zichtbaar") {
		t.Fatalf("anonieme api filter: %#v %#v", pubAPI["repos"], pubAPI["groups"])
	}
	if pubAPI["counts"].(map[string]any)["contributions"] != 1.0 {
		t.Fatalf("anonieme api lekt privébijdragen: %#v", pubAPI["counts"])
	}
	badTok, err := http.NewRequest(http.MethodGet, ts.URL+"/api/v1/users/tim", nil)
	if err != nil {
		t.Fatal(err)
	}
	badTok.Header.Set("Authorization", "Bearer bg_nietgeldig")
	res, err = http.DefaultClient.Do(badTok)
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusUnauthorized {
		t.Fatalf("ongeldig token %d", res.StatusCode)
	}
	_ = res.Body.Close()
	req, err := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/user", strings.NewReader(`{"bio":"alleen bio"}`))
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer "+timToken)
	req.Header.Set("Content-Type", "application/json")
	res, err = http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	put := decodeJSON(t, res)
	if put["bio"] != "alleen bio" || put["name"] != "Tim Falken" || put["language"] != "en" {
		t.Fatalf("put bio: %#v", put)
	}

	noredir := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
	res, err = noredir.Get(ts.URL + "/tim")
	if err != nil {
		t.Fatal(err)
	}
	loc := res.Header.Get("Location")
	if res.StatusCode != http.StatusFound || loc != "/users/tim" {
		t.Fatalf("/tim is %d locatie %q", res.StatusCode, loc)
	}
	_ = res.Body.Close()
	res, err = noredir.Get(ts.URL + "/plein")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusNotFound || res.Header.Get("Location") != "" {
		t.Fatalf("groepsnaam /plein is %d locatie %q", res.StatusCode, res.Header.Get("Location"))
	}
	_ = res.Body.Close()
	res, err = noredir.Get(ts.URL + "/tim/zichtbaar")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode == http.StatusFound && strings.HasPrefix(res.Header.Get("Location"), "/users/") {
		t.Fatalf("repositorypad wijst naar een profiel: %s", res.Header.Get("Location"))
	}
	_ = res.Body.Close()
	res, err = noredir.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(res.Header.Get("Location"), "/users/") {
		t.Fatalf("login wijst naar een profiel: %s", res.Header.Get("Location"))
	}
	_ = res.Body.Close()
	res, err = anon.Get(ts.URL + "/users/nobody")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusNotFound {
		t.Fatalf("onbekend profiel %d", res.StatusCode)
	}
	_ = res.Body.Close()
	_ = page
}

func repoID(t *testing.T, st *store.Store, owner, name string) int64 {
	t.Helper()
	repo, err := st.RepoByPath(context.Background(), owner, name)
	if err != nil {
		t.Fatal(err)
	}
	return repo.ID
}

func apiGet(t *testing.T, rawURL, token string) map[string]any {
	t.Helper()
	req, err := http.NewRequest(http.MethodGet, rawURL, nil)
	if err != nil {
		t.Fatal(err)
	}
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	body := decodeJSON(t, res)
	if res.StatusCode != http.StatusOK {
		t.Fatalf("api %s: %d %#v", rawURL, res.StatusCode, body)
	}
	return body
}

func decodeJSON(t *testing.T, res *http.Response) map[string]any {
	t.Helper()
	defer res.Body.Close()
	var body map[string]any
	if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	return body
}

type pathSet map[string]bool

func apiPaths(v any) pathSet {
	out := pathSet{}
	list, _ := v.([]any)
	for _, item := range list {
		row, _ := item.(map[string]any)
		if p, ok := row["path"].(string); ok {
			out[p] = true
		}
	}
	return out
}

func (p pathSet) has(want ...string) bool {
	for _, w := range want {
		if !p[w] {
			return false
		}
	}
	return true
}
