package web

import (
	"context"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"github.com/go-chi/chi/v5"

	"hearthforge/internal/config"
	"hearthforge/internal/db"
	"hearthforge/internal/gitcmd"
	"hearthforge/internal/highlight"
	"hearthforge/internal/markdown"
)

// repoTestServer returns a router with the repo routes and an admin user.
func repoTestServer(t *testing.T) (http.Handler, *Server, *db.SessionUser) {
	t.Helper()
	ctx := context.Background()
	dataDir := t.TempDir()
	d, err := db.Open(filepath.Join(dataDir, "hearthforge.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { d.Close() })
	if _, err := d.InitAdmin(ctx, "hunter2"); err != nil {
		t.Fatal(err)
	}
	admin, err := d.UserByName(ctx, db.AdminUsername)
	if err != nil || admin == nil {
		t.Fatalf("admin lookup failed: %v", err)
	}

	cfg := &config.Config{
		DataDir:           dataDir,
		OwnerDisplayName:  "Admin",
		BaseURL:           "http://localhost:3000",
		SSHPort:           2222,
		InlineMaxBytes:    512 << 10,
		MaxRenderBytes:    10 << 20,
		MaxTitleBytes:     500,
		MaxTextBodyBytes:  100000,
		CommitterName:     "Admin",
		CommitterEmail:    "admin@localhost",
		RateLimitDisabled: true,
	}
	cfg.SSHHostKeyPath = filepath.Join(dataDir, "ssh_host_key")
	if err := os.MkdirAll(cfg.ReposDir(), 0o755); err != nil {
		t.Fatal(err)
	}
	// Commits made through the UI are ssh-signed, so the host key must exist.
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git not installed")
	}
	keygen := exec.Command("ssh-keygen", "-t", "ed25519", "-N", "", "-f", cfg.SSHHostKeyPath, "-C", "test")
	if out, err := keygen.CombinedOutput(); err != nil {
		t.Skipf("ssh-keygen unavailable: %v: %s", err, out)
	}
	s := &Server{
		Cfg: cfg,
		DB:  d,
		MD:  markdown.New(),
		HL:  highlight.New(cfg.InlineMaxBytes),
		Git: gitcmd.New(cfg),
	}
	r := chi.NewRouter()
	s.repoRoutes(r)
	return r, s, &db.SessionUser{ID: admin.ID, Username: db.AdminUsername, IsAdmin: true}
}

func TestRepoCreateBrowseAndEdit(t *testing.T) {
	h, s, admin := repoTestServer(t)

	res := do(t, h, admin, "POST", "/new", url.Values{
		"name": {"my-repo"}, "description": {"A demo"}, "default_branch": {"main"},
	})
	if res.Code != http.StatusFound {
		t.Fatalf("create repo status = %d, body %s", res.Code, res.Body.String())
	}
	if got := res.Header().Get("Location"); got != "/my-repo" {
		t.Fatalf("create repo redirected to %q", got)
	}
	bare := filepath.Join(s.Cfg.ReposDir(), "my-repo.git")
	if _, err := os.Stat(filepath.Join(bare, "HEAD")); err != nil {
		t.Fatalf("bare repo missing on disk: %v", err)
	}

	// The UI create-file route must produce a real commit.
	res = do(t, h, admin, "POST", "/my-repo/new-file/main", url.Values{
		"path": {"README.md"}, "content": {"# Hello\n\nworld\n"}, "message": {"Add README"},
	})
	if res.Code != http.StatusFound {
		t.Fatalf("create file status = %d, body %s", res.Code, res.Body.String())
	}
	commitURL := res.Header().Get("Location")
	if !strings.HasPrefix(commitURL, "/my-repo/commit/") {
		t.Fatalf("create file redirected to %q", commitURL)
	}
	commits, err := s.Git.Log(context.Background(), "my-repo", "main", 10, 0)
	if err != nil || len(commits) != 1 {
		t.Fatalf("log = %v, err %v", commits, err)
	}
	if commits[0].Subject != "Add README" {
		t.Errorf("commit subject = %q", commits[0].Subject)
	}

	res = do(t, h, admin, "GET", "/my-repo", nil)
	body := res.Body.String()
	if res.Code != http.StatusOK {
		t.Fatalf("home status = %d", res.Code)
	}
	if !strings.Contains(body, "README.md") {
		t.Error("repo home did not list the file")
	}
	if !strings.Contains(body, "<h1") || !strings.Contains(body, "Hello") {
		t.Error("repo home did not render the README")
	}

	res = do(t, h, admin, "GET", "/my-repo/blob/main/README.md", nil)
	if res.Code != http.StatusOK {
		t.Fatalf("blob status = %d", res.Code)
	}
	if !strings.Contains(res.Body.String(), "markdown-body") {
		t.Error("blob view did not render the markdown body")
	}

	res = do(t, h, admin, "GET", "/my-repo/blob/main/notes.txt", nil)
	if res.Code != http.StatusNotFound {
		t.Fatalf("missing blob status = %d, want 404", res.Code)
	}

	res = do(t, h, admin, "GET", "/my-repo/commits/main", nil)
	if res.Code != http.StatusOK {
		t.Fatalf("commit log status = %d", res.Code)
	}
	if !strings.Contains(res.Body.String(), "Add README") {
		t.Error("commit log did not show the commit")
	}

	res = do(t, h, admin, "GET", commitURL, nil)
	if res.Code != http.StatusOK {
		t.Fatalf("commit detail status = %d", res.Code)
	}

	res = do(t, h, admin, "GET", "/my-repo/raw/main/README.md", nil)
	if res.Code != http.StatusOK {
		t.Fatalf("raw status = %d", res.Code)
	}
	if got := res.Body.String(); got != "# Hello\n\nworld\n" {
		t.Errorf("raw body = %q", got)
	}
}

func TestRepoHighlightedBlob(t *testing.T) {
	h, _, admin := repoTestServer(t)
	do(t, h, admin, "POST", "/new", url.Values{"name": {"code"}, "default_branch": {"main"}})
	do(t, h, admin, "POST", "/code/new-file/main", url.Values{
		"path": {"main.go"}, "content": {"package main\n"},
	})

	res := do(t, h, admin, "GET", "/code/blob/main/main.go", nil)
	if res.Code != http.StatusOK {
		t.Fatalf("blob status = %d", res.Code)
	}
	body := res.Body.String()
	if !strings.Contains(body, "code-wrapper") {
		t.Error("blob view did not render the highlighted table")
	}
	if !strings.Contains(body, "package") {
		t.Error("blob view did not contain the file contents")
	}
}

func TestRepoPrivateHiddenFromAnonymous(t *testing.T) {
	h, _, admin := repoTestServer(t)
	do(t, h, admin, "POST", "/new", url.Values{"name": {"hidden"}, "is_private": {"1"}})

	if res := do(t, h, nil, "GET", "/hidden", nil); res.Code != http.StatusNotFound {
		t.Fatalf("anonymous status = %d, want 404", res.Code)
	}
	if res := do(t, h, admin, "GET", "/hidden", nil); res.Code != http.StatusOK {
		t.Fatalf("admin status = %d, want 200", res.Code)
	}
}

// An empty repo, an unknown branch and a stale `after` cursor all render an
// empty commit list.
func TestCommitLogToleratesMissingRefs(t *testing.T) {
	h, _, admin := repoTestServer(t)
	if res := do(t, h, admin, "POST", "/new", url.Values{
		"name": {"empty-anvil"}, "default_branch": {"main"},
	}); res.Code != http.StatusFound {
		t.Fatalf("create repo status = %d", res.Code)
	}
	for _, target := range []string{
		"/empty-anvil/commits/main",
		"/empty-anvil/commits/nope",
		"/empty-anvil/commits/main?after=e4bdf91390fbb8d693bf32de298f3a5c7d766106",
	} {
		if res := do(t, h, admin, "GET", target, nil); res.Code != http.StatusOK {
			t.Errorf("GET %s = %d, want 200", target, res.Code)
		}
	}
}

// chi keeps %2F encoded, so a branch name with a slash only works if the
// handlers unescape the {ref} parameter.
func TestBranchNameWithSlash(t *testing.T) {
	h, _, admin := repoTestServer(t)
	if res := do(t, h, admin, "POST", "/new", url.Values{
		"name": {"forge-core"}, "default_branch": {"main"},
	}); res.Code != http.StatusFound {
		t.Fatalf("create repo status = %d", res.Code)
	}
	if res := do(t, h, admin, "POST", "/forge-core/new-file/main", url.Values{
		"path": {"README.md"}, "content": {"hi\n"}, "message": {"init"},
	}); res.Code != http.StatusFound {
		t.Fatalf("create file status = %d", res.Code)
	}
	if res := do(t, h, admin, "POST", "/forge-core/branches/create", url.Values{
		"name": {"feature/widgets"}, "source_ref": {"main"},
	}); res.Code != http.StatusFound {
		t.Fatalf("create branch status = %d", res.Code)
	}
	for _, target := range []string{
		"/forge-core/tree/feature%2Fwidgets",
		"/forge-core/commits/feature%2Fwidgets",
		"/forge-core/blob/feature%2Fwidgets/README.md",
	} {
		res := do(t, h, admin, "GET", target, nil)
		if res.Code != http.StatusOK {
			t.Errorf("GET %s = %d, want 200", target, res.Code)
		}
	}
}

// refParam decodes exactly once. chi matches on the escaped path, so a route
// parameter always arrives percent-encoded and "%2F" survives as a ref
// separator. A name that is already plain must not be decoded a second time.
func TestRefParamDecodesOnce(t *testing.T) {
	r := chi.NewRouter()
	var gotRef, gotPath string
	r.Get("/{repo}/blob/{ref}/*", func(w http.ResponseWriter, req *http.Request) {
		gotRef, gotPath = refParam(req, "ref"), refParam(req, "*")
	})
	cases := []struct{ target, ref, path string }{
		// A branch name with a slash only survives the route escaped.
		{"/x/blob/feature%2Fwidgets/docs/a.md", "feature/widgets", "docs/a.md"},
		// "%2e" is the client asking for ".", not a literal percent sequence.
		{"/x/blob/main/a%2e", "main", "a."},
		// A file really named "a%2e" is requested double-escaped.
		{"/x/blob/main/a%252e", "main", "a%2e"},
		{"/x/blob/main/plain.txt", "main", "plain.txt"},
	}
	for _, c := range cases {
		gotRef, gotPath = "", ""
		r.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, c.target, nil))
		if gotRef != c.ref || gotPath != c.path {
			t.Errorf("%s: ref = %q, path = %q, want %q, %q", c.target, gotRef, gotPath, c.ref, c.path)
		}
	}
}

func TestRawDocumentTypesAreSandboxed(t *testing.T) {
	h, _, admin := repoTestServer(t)
	do(t, h, admin, "POST", "/new", url.Values{"name": {"docs"}, "default_branch": {"main"}})
	do(t, h, admin, "POST", "/docs/new-file/main", url.Values{
		"path":    {"logo.svg"},
		"content": {`<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>`},
	})
	do(t, h, admin, "POST", "/docs/new-file/main", url.Values{
		"path": {"page.html"}, "content": {"<!doctype html><script>alert(1)</script>"},
	})
	do(t, h, admin, "POST", "/docs/new-file/main", url.Values{
		"path": {"notes.txt"}, "content": {"plain\n"},
	})

	for _, tc := range []struct {
		path, wantType string
		sandboxed      bool
	}{
		{"/docs/raw/main/logo.svg", "image/svg+xml", true},
		{"/docs/raw/main/page.html", "text/html", true},
		{"/docs/raw/main/notes.txt", "text/plain", false},
	} {
		res := do(t, h, admin, "GET", tc.path, nil)
		if res.Code != http.StatusOK {
			t.Fatalf("%s: status = %d", tc.path, res.Code)
		}
		if ct := res.Header().Get("Content-Type"); !strings.HasPrefix(ct, tc.wantType) {
			t.Errorf("%s: Content-Type = %q, want prefix %q", tc.path, ct, tc.wantType)
		}
		csp := res.Header().Get("Content-Security-Policy")
		if tc.sandboxed && !strings.Contains(csp, "sandbox;") {
			t.Errorf("%s: missing sandbox CSP, got %q", tc.path, csp)
		}
		if !tc.sandboxed && csp != "" {
			t.Errorf("%s: unexpected CSP %q", tc.path, csp)
		}
	}
}

func TestIsDocumentType(t *testing.T) {
	for in, want := range map[string]bool{
		"text/html; charset=utf-8": true,
		"IMAGE/SVG+XML":            true,
		"application/rss+xml":      true,
		"text/plain":               false,
		"image/png":                false,
		"application/json":         false,
	} {
		if got := isDocumentType(in); got != want {
			t.Errorf("isDocumentType(%q) = %v, want %v", in, got, want)
		}
	}
}