package web

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"testing/fstest"

	"khosra/internal/content"
	"khosra/internal/render"
)

func testHandler(t *testing.T) http.Handler {
	t.Helper()
	fsys := fstest.MapFS{
		"content/pages/about.md":       {Data: []byte("---\ntitle: About\n---\nAbout me.\n")},
		"content/posts/hello/index.md": {Data: []byte("---\ntitle: Hello\n---\nFirst post.\n")},
	}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(nil)
	if err != nil {
		t.Fatal(err)
	}
	return Handler(content.NewSite(bundles), r, fsys)
}

func TestServeBundleAtItsPermalink(t *testing.T) {
	h := testHandler(t)
	for _, path := range []string{"/pages/about/", "/posts/hello/"} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != http.StatusOK {
			t.Fatalf("GET %s = %d, want 200", path, rec.Code)
		}
		if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/html") {
			t.Errorf("GET %s content-type = %q", path, ct)
		}
	}
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/pages/about/", nil))
	if body := rec.Body.String(); !strings.Contains(body, "<h1>About</h1>") || !strings.Contains(body, "About me.") {
		t.Errorf("body did not render the bundle:\n%s", body)
	}
}

func TestSlashlessPathRedirectsPermanently(t *testing.T) {
	h := testHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/pages/about", nil))
	if rec.Code != http.StatusMovedPermanently {
		t.Fatalf("got %d, want 301", rec.Code)
	}
	if loc := rec.Header().Get("Location"); loc != "/pages/about/" {
		t.Errorf("Location = %q", loc)
	}
}

func TestUnknownPathsAre404(t *testing.T) {
	h := testHandler(t)
	for _, path := range []string{"/", "/nope/", "/pages/nope", "/pages/about/deeper/"} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != http.StatusNotFound {
			t.Errorf("GET %s = %d, want 404", path, rec.Code)
		}
	}
}

func multilingualHandler(t *testing.T) http.Handler {
	t.Helper()
	fsys := fstest.MapFS{
		"content/pages/about.md":    {Data: []byte("---\ntitle: About\n---\nEnglish.\n")},
		"content/pages/about.bn.md": {Data: []byte("---\ntitle: পরিচিতি\n---\nবাংলা।\n")},
		"content/pages/now.md":      {Data: []byte("---\ntitle: Now\n---\nOnly English.\n")},
	}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(nil)
	if err != nil {
		t.Fatal(err)
	}
	return Handler(content.NewSite(bundles), r, fsys)
}

func TestPrefixedLanguageServesThatVariant(t *testing.T) {
	h := multilingualHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/about/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("got %d, want 200", rec.Code)
	}
	body := rec.Body.String()
	if !strings.Contains(body, "বাংলা।") || !strings.Contains(body, `lang="bn"`) {
		t.Errorf("did not serve the Bengali variant:\n%s", body)
	}
	if !strings.Contains(body, `rel="canonical" href="/bn/pages/about/"`) {
		t.Error("canonical should name the variant actually served")
	}
	if !strings.Contains(body, `hreflang="en" href="/pages/about/"`) {
		t.Error("hreflang should list the English variant at the root form")
	}
}

func TestMissingVariantFallsBackAndSaysSo(t *testing.T) {
	h := multilingualHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/now/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("got %d, want 200: the fallback chain must not 404 (ADR-0009)", rec.Code)
	}
	body := rec.Body.String()
	if !strings.Contains(body, "Only English.") {
		t.Error("expected the English body as fallback")
	}
	if !strings.Contains(body, `rel="canonical" href="/pages/now/"`) {
		t.Error("canonical must point at the variant served, not the URL requested")
	}
}

func TestDefaultLanguagePrefixRedirectsToRoot(t *testing.T) {
	h := multilingualHandler(t)
	for path, want := range map[string]string{
		"/en/pages/about/": "/pages/about/",
		"/en/pages/about":  "/pages/about/",
	} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != http.StatusMovedPermanently {
			t.Errorf("GET %s = %d, want 301: /en/… must never be live (ADR-0009)", path, rec.Code)
			continue
		}
		if loc := rec.Header().Get("Location"); loc != want {
			t.Errorf("GET %s → %q, want %q", path, loc, want)
		}
	}
}

func TestPrefixedSlashlessPathRedirectsWithItsPrefix(t *testing.T) {
	h := multilingualHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/bn/pages/about", nil))
	if rec.Code != http.StatusMovedPermanently {
		t.Fatalf("got %d, want 301", rec.Code)
	}
	if loc := rec.Header().Get("Location"); loc != "/bn/pages/about/" {
		t.Errorf("Location = %q, want /bn/pages/about/", loc)
	}
}

func TestUnknownLanguagePrefixIsNotALanguage(t *testing.T) {
	h := multilingualHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/fr/pages/about/", nil))
	if rec.Code != http.StatusNotFound {
		t.Errorf("got %d, want 404: fr is not a language this site has", rec.Code)
	}
}

func aliasHandler(t *testing.T) http.Handler {
	t.Helper()
	fsys := fstest.MapFS{
		"content/posts/new-name.md":    {Data: []byte("---\ntitle: New\naliases: [posts/old-name]\n---\nMoved here.\n")},
		"content/posts/new-name.bn.md": {Data: []byte("---\ntitle: নতুন\n---\nএখানে।\n")},
	}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(nil)
	if err != nil {
		t.Fatal(err)
	}
	return Handler(content.NewSite(bundles), r, fsys)
}

func TestAliasRedirectsToCanonical(t *testing.T) {
	h := aliasHandler(t)
	for path, want := range map[string]string{
		"/posts/old-name/":    "/posts/new-name/",
		"/bn/posts/old-name/": "/bn/posts/new-name/",
	} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != http.StatusMovedPermanently {
			t.Errorf("GET %s = %d, want 301", path, rec.Code)
			continue
		}
		if loc := rec.Header().Get("Location"); loc != want {
			t.Errorf("GET %s → %q, want %q", path, loc, want)
		}
	}
}

func TestUnknownPathIsStill404NotAnAliasProbe(t *testing.T) {
	h := aliasHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/never-existed/", nil))
	if rec.Code != http.StatusNotFound {
		t.Errorf("got %d, want 404", rec.Code)
	}
}

func listingHandler(t *testing.T, n int) http.Handler {
	t.Helper()
	fsys := fstest.MapFS{}
	for i := 1; i <= n; i++ {
		name := fmt.Sprintf("content/posts/post-%02d.md", i)
		body := fmt.Sprintf("---\ntitle: Post %02d\ndate: 2026-01-%02d\n---\nBody %d.\n", i, i, i)
		fsys[name] = &fstest.MapFile{Data: []byte(body)}
	}
	fsys["content/pages/about.md"] = &fstest.MapFile{Data: []byte("---\ntitle: About\n---\nx\n")}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(nil)
	if err != nil {
		t.Fatal(err)
	}
	return Handler(content.NewSite(bundles), r, fsys)
}

func TestSectionIndexListsNewestFirst(t *testing.T) {
	h := listingHandler(t, 3)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("got %d, want 200", rec.Code)
	}
	body := rec.Body.String()
	first, third := strings.Index(body, "Post 03"), strings.Index(body, "Post 01")
	if first < 0 || third < 0 || first > third {
		t.Errorf("newest should come first:\n%s", body)
	}
	if strings.Contains(body, "About") {
		t.Error("a section listing must not leak another section's bundles")
	}
}

func TestPaginationSplitsAndLinks(t *testing.T) {
	h := listingHandler(t, content.PerPage+2)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/", nil))
	body := rec.Body.String()
	if strings.Count(body, "<li>") != content.PerPage {
		t.Errorf("page one holds %d entries, want %d", strings.Count(body, "<li>"), content.PerPage)
	}
	if !strings.Contains(body, `rel="next" href="/posts/page/2/"`) || strings.Contains(body, `rel="prev"`) {
		t.Errorf("page one should link next and not prev:\n%s", body)
	}
	rec = httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/2/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("page two = %d, want 200", rec.Code)
	}
	body = rec.Body.String()
	if strings.Count(body, "<li>") != 2 {
		t.Errorf("page two holds %d entries, want 2", strings.Count(body, "<li>"))
	}
	if !strings.Contains(body, `rel="prev" href="/posts/"`) {
		t.Errorf("page two should link back to the bare listing URL:\n%s", body)
	}
}

func TestPageOneIsNeverItsOwnURL(t *testing.T) {
	h := listingHandler(t, 3)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/1/", nil))
	if rec.Code != http.StatusMovedPermanently {
		t.Fatalf("got %d, want 301 (ADR-0028)", rec.Code)
	}
	if loc := rec.Header().Get("Location"); loc != "/posts/" {
		t.Errorf("Location = %q, want /posts/", loc)
	}
}

func TestPagePastTheEndIs404(t *testing.T) {
	h := listingHandler(t, 3)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/posts/page/9/", nil))
	if rec.Code != http.StatusNotFound {
		t.Errorf("got %d, want 404: an empty page is a URL that means nothing", rec.Code)
	}
}

func TestStaticFilesAreServedAndDirectoriesAreNot(t *testing.T) {
	fsys := fstest.MapFS{
		"content/pages/about.md": {Data: []byte("---\ntitle: About\n---\nx\n")},
		"static/style.css":       {Data: []byte("body{}")},
		"static/img/logo.svg":    {Data: []byte("<svg/>")},
	}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(fsys)
	if err != nil {
		t.Fatal(err)
	}
	h := Handler(content.NewSite(bundles), r, fsys)
	for path, want := range map[string]int{
		"/static/style.css":    http.StatusOK,
		"/static/img/logo.svg": http.StatusOK,
		"/static/":             http.StatusNotFound,
		"/static/img/":         http.StatusNotFound,
		"/static/nope.css":     http.StatusNotFound,
	} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != want {
			t.Errorf("GET %s = %d, want %d", path, rec.Code, want)
		}
	}
}

func tagHandler(t *testing.T) http.Handler {
	t.Helper()
	fsys := fstest.MapFS{
		"content/posts/essay.md": {Data: []byte("---\ntitle: Essay\ndate: 2026-01-03\ntags: [Monsoon]\n---\n")},
		"content/comics/rain.md": {Data: []byte("---\ntitle: Rain\ndate: 2026-01-02\ntags: [monsoon]\n---\n")},
		"content/posts/other.md": {Data: []byte("---\ntitle: Other\ndate: 2026-01-01\ntags: [prose]\n---\n")},
	}
	bundles, err := content.Scan(fsys)
	if err != nil {
		t.Fatal(err)
	}
	r, err := render.New(nil)
	if err != nil {
		t.Fatal(err)
	}
	return Handler(content.NewSite(bundles), r, nil)
}

func TestGlobalTagListingSpansSectionsGroupedByOne(t *testing.T) {
	h := tagHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/tags/monsoon/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("got %d, want 200", rec.Code)
	}
	body := rec.Body.String()
	for _, want := range []string{"<h2>posts</h2>", "<h2>comics</h2>", "Essay", "Rain"} {
		if !strings.Contains(body, want) {
			t.Errorf("missing %q — a tag spans sections and groups by one:\n%s", want, body)
		}
	}
	if strings.Contains(body, "Other") {
		t.Error("a different tag leaked in")
	}
}

func TestSectionNarrowedTagListing(t *testing.T) {
	h := tagHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/comics/tags/monsoon/", nil))
	if rec.Code != http.StatusOK {
		t.Fatalf("got %d, want 200", rec.Code)
	}
	body := rec.Body.String()
	if !strings.Contains(body, "Rain") || strings.Contains(body, "Essay") {
		t.Errorf("narrowing to comics should drop the posts entry:\n%s", body)
	}
}

func TestTagPathsCanonicaliseAndMiss(t *testing.T) {
	h := tagHandler(t)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/tags/monsoon", nil))
	if rec.Code != http.StatusMovedPermanently || rec.Header().Get("Location") != "/tags/monsoon/" {
		t.Errorf("slashless tag path = %d %q", rec.Code, rec.Header().Get("Location"))
	}
	for _, path := range []string{"/tags/nothing/", "/tags/", "/posts/tags/nothing/"} {
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
		if rec.Code != http.StatusNotFound {
			t.Errorf("GET %s = %d, want 404", path, rec.Code)
		}
	}
}