package cli

import (
	"bytes"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/lukaszkasprzak/lectio/internal/bible"
	"github.com/lukaszkasprzak/lectio/internal/liturgy"
)

func TestHelp(t *testing.T) {
	var out, errb bytes.Buffer
	code := Run([]string{"help"}, nil, &out, &errb)
	if code != 0 || !strings.Contains(out.String(), "lectio") {
		t.Errorf("help code=%d out=%q", code, out.String())
	}
}

func TestHelpFlag(t *testing.T) {
	var out, errb bytes.Buffer
	code := Run([]string{"-h"}, nil, &out, &errb)
	if code != 0 || !strings.Contains(out.String(), "lectio") {
		t.Errorf("-h code=%d out=%q", code, out.String())
	}
}

func TestUnexpectedPositional(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"bogus"}, nil, &out, &errb); code != 2 {
		t.Errorf("unexpected positional code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

func TestVersion(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"--version"}, nil, &out, &errb); code != 0 {
		t.Errorf("version code=%d", code)
	}
}

// TestBadDate exercises the usage-error path for a malformed date: a token
// that doesn't match dateRe's YYYY-MM-DD shape is left as an unrecognised
// positional argument once flag parsing is done, which is a usage error.
func TestBadDate(t *testing.T) {
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
	var out, errb bytes.Buffer
	if code := Run([]string{"13-13-13"}, nil, &out, &errb); code != 2 {
		t.Errorf("bad date code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

// TestTwoDatesIsAmbiguous exercises extractDate's ambiguity check: two
// dateRe-shaped tokens can't both be the positional date.
func TestTwoDatesIsAmbiguous(t *testing.T) {
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
	var out, errb bytes.Buffer
	if code := Run([]string{"2026-07-22", "2026-07-23"}, nil, &out, &errb); code != 2 {
		t.Errorf("two dates code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

// TestUnknownVersion exercises -b/--bible's version-validation usage-error
// path without touching the network: the version code is checked against
// the five known codes before any fetch is attempted.
func TestUnknownVersion(t *testing.T) {
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
	var out, errb bytes.Buffer
	if code := Run([]string{"-b", "zzz"}, nil, &out, &errb); code != 2 {
		t.Errorf("unknown version code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

// TestLectionaryTradMapsToTraditional exercises -l/--lectionary's trad ->
// traditional normalisation. It goes through extractDate/flag parsing and
// validation only (no network): a bogus date lets it exit before any fetch
// is attempted, but only after the -l value has already been validated and
// mapped, which is what this test checks indirectly via the exit code (a
// bad --lectionary would exit 2 for a different reason, so this alone
// wouldn't distinguish the two -- see TestLectionaryBogus for that side).
// Exercised directly against parseFlags below.
func TestLectionaryTradMapsToTraditional(t *testing.T) {
	lectionary, err := normalizeLectionary("trad")
	if err != nil {
		t.Fatalf("normalizeLectionary(trad): %v", err)
	}
	if lectionary != "traditional" {
		t.Errorf("normalizeLectionary(trad) = %q, want traditional", lectionary)
	}
}

func TestLectionaryBogus(t *testing.T) {
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
	var out, errb bytes.Buffer
	if code := Run([]string{"-l", "bogus"}, nil, &out, &errb); code != 2 {
		t.Errorf("bogus lectionary code=%d want 2 (stderr=%q)", code, errb.String())
	}
	if _, err := normalizeLectionary("bogus"); err == nil {
		t.Error("normalizeLectionary(bogus): want error, got nil")
	}
}

func TestLangBogus(t *testing.T) {
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
	var out, errb bytes.Buffer
	if code := Run([]string{"-g", "de"}, nil, &out, &errb); code != 2 {
		t.Errorf("bogus lang code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

// TestBannerForLang checks bannerFor's wording follows lang: pl reproduces
// the pre-i18n Polish banner exactly ("Ewangelia na D" / "Czytania na D"),
// en gives "Gospel for D" / "Readings for D".
func TestBannerForLang(t *testing.T) {
	cases := []struct {
		lang string
		all  bool
		want string
	}{
		{"pl", false, "Ewangelia na 2026-07-22"},
		{"pl", true, "Czytania na 2026-07-22"},
		{"en", false, "Gospel for 2026-07-22"},
		{"en", true, "Readings for 2026-07-22"},
	}
	for _, c := range cases {
		if got := bannerFor(c.lang, c.all, "2026-07-22"); got != c.want {
			t.Errorf("bannerFor(%q, %v, ...) = %q, want %q", c.lang, c.all, got, c.want)
		}
	}
}

// TestCleanEmptyCache exercises -C/--clean's dispatch as a maintenance mode:
// it must be handled before any render path (and before the network-hitting
// -u/--update path) is reached. Pointing XDG_CACHE_HOME at an empty temp dir
// keeps liturgy.CleanCache's directory-read hermetic (no network), and an
// empty dir exercises the "nothing to remove" branch of the summary line.
func TestCleanEmptyCache(t *testing.T) {
	t.Setenv("XDG_CACHE_HOME", t.TempDir())
	var out, errb bytes.Buffer
	code := Run([]string{"-C"}, nil, &out, &errb)
	if code != 0 {
		t.Fatalf("--clean code=%d want 0 (stderr=%q)", code, errb.String())
	}
	if !strings.Contains(out.String(), "clean") {
		t.Errorf("--clean stdout=%q, want a clean/nothing message", out.String())
	}
}

// TestCleanRemovesOldEntries exercises the non-empty summary branch: a stale
// cache pair sitting in XDG_CACHE_HOME must be reported as removed, entirely
// via the filesystem (no network involved).
func TestCleanRemovesOldEntries(t *testing.T) {
	dir := t.TempDir()
	t.Setenv("XDG_CACHE_HOME", dir)
	cacheDir := filepath.Join(dir, "lectio")
	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(cacheDir, "2020-01-01.html"), []byte("<html>old</html>"), 0o644); err != nil {
		t.Fatal(err)
	}

	var out, errb bytes.Buffer
	code := Run([]string{"--clean"}, nil, &out, &errb)
	if code != 0 {
		t.Fatalf("--clean code=%d want 0 (stderr=%q)", code, errb.String())
	}
	if !strings.Contains(out.String(), "cleaned 1 cache entry") {
		t.Errorf("--clean stdout=%q, want a \"cleaned 1 cache entry\" message", out.String())
	}
	if _, err := os.Stat(filepath.Join(cacheDir, "2020-01-01.html")); !os.IsNotExist(err) {
		t.Errorf("2020-01-01.html still exists after --clean")
	}
}

// TestCleanPreferredOverUpdate exercises Run's stated precedence: when both
// --clean and -u/--update are given, --clean wins and -u's network-hitting
// harvest path is never reached (proven here by the empty-cache dir plus a
// zero exit code -- a network attempt against no test server would either
// hang or return an error/non-zero code).
func TestCleanPreferredOverUpdate(t *testing.T) {
	t.Setenv("XDG_CACHE_HOME", t.TempDir())
	var out, errb bytes.Buffer
	code := Run([]string{"--clean", "-u"}, nil, &out, &errb)
	if code != 0 {
		t.Fatalf("--clean -u code=%d want 0 (stderr=%q)", code, errb.String())
	}
	if !strings.Contains(out.String(), "clean") {
		t.Errorf("--clean -u stdout=%q, want a clean/nothing message", out.String())
	}
}

// TestDayInfoHeaderShown exercises fetchAndPrint's day-info header end to
// end (via Run against a fixture server, matching internal/readings'
// TestLoadModernRoutes): the day's celebration name appears above the
// banner for the default (non-raw) render, and is entirely absent from
// --raw output, which stays text-only for piping.
func TestDayInfoHeaderShown(t *testing.T) {
	html, err := os.ReadFile("../liturgy/testdata/2026-07-22.html")
	if err != nil {
		t.Fatal(err)
	}
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write(html)
	}))
	defer srv.Close()
	liturgy.SetBaseURL(srv.URL + "/liturgia/%s/Ewangelia")
	t.Setenv("XDG_CACHE_HOME", t.TempDir())
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())

	var out, errb bytes.Buffer
	if code := Run([]string{"2026-07-22"}, nil, &out, &errb); code != 0 {
		t.Fatalf("Run code=%d stderr=%q", code, errb.String())
	}
	if !strings.Contains(out.String(), "Święto św. Marii Magdaleny") {
		t.Errorf("stdout missing day-info header: %q", out.String())
	}

	out.Reset()
	errb.Reset()
	if code := Run([]string{"2026-07-22", "-r"}, nil, &out, &errb); code != 0 {
		t.Fatalf("Run --raw code=%d stderr=%q", code, errb.String())
	}
	if strings.Contains(out.String(), "Święto św. Marii Magdaleny") {
		t.Errorf("--raw stdout should omit the day-info header: %q", out.String())
	}
}

// TestDateTokenAnyPosition exercises extractDate directly: the date token
// is found regardless of where it appears among other flags.
func TestDateTokenAnyPosition(t *testing.T) {
	cases := [][]string{
		{"-a", "2026-07-22"},
		{"2026-07-22", "-a"},
		{"-a", "2026-07-22", "-r"},
	}
	for _, args := range cases {
		date, rest, err := extractDate(args)
		if err != nil {
			t.Fatalf("extractDate(%v): %v", args, err)
		}
		if date != "2026-07-22" {
			t.Errorf("extractDate(%v) date = %q, want 2026-07-22", args, date)
		}
		for _, r := range rest {
			if r == "2026-07-22" {
				t.Errorf("extractDate(%v) rest = %v still contains the date", args, rest)
			}
		}
	}
}

// TestExtractDateDefaultsToday checks that omitting a date token leaves
// today's date and passes every token through untouched.
func TestExtractDateDefaultsToday(t *testing.T) {
	date, rest, err := extractDate([]string{"-a", "-r"})
	if err != nil {
		t.Fatalf("extractDate: %v", err)
	}
	if date != today() {
		t.Errorf("extractDate date = %q, want today() = %q", date, today())
	}
	if len(rest) != 2 || rest[0] != "-a" || rest[1] != "-r" {
		t.Errorf("extractDate rest = %v, want [-a -r]", rest)
	}
}

func TestRefSingle(t *testing.T) {
	var out, errb bytes.Buffer
	code := Run([]string{"-p", "Jn 3:16", "-b", "vul"}, nil, &out, &errb)
	if code != 0 {
		t.Fatalf("ref code=%d stderr=%q", code, errb.String())
	}
	if s := out.String(); !strings.Contains(s, "3:16") {
		t.Errorf("ref output missing verse 3:16:\n%s", s)
	}
}

func TestRefNotFound(t *testing.T) {
	var out, errb bytes.Buffer
	// An unknown book -> ParseRef fails to resolve it in the dialect -> exit 2.
	if code := Run([]string{"-p", "Zzz 9:9", "-b", "vul"}, nil, &out, &errb); code != 2 {
		t.Errorf("ref unknown-book code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

func TestRunListEnglish(t *testing.T) {
	tbl, _ := bible.LoadBookTable(nil)
	var out bytes.Buffer
	if code := runList(tbl, "en", &out); code != 0 {
		t.Fatalf("runList en code=%d", code)
	}
	if s := out.String(); !strings.Contains(s, "Jn") || !strings.Contains(s, "John") {
		t.Errorf("en list missing Jn/John:\n%s", s)
	}
}

func TestRunListPolish(t *testing.T) {
	tbl, _ := bible.LoadBookTable(nil)
	var out bytes.Buffer
	runList(tbl, "pl", &out)
	if s := out.String(); !strings.Contains(s, "Jana") || !strings.Contains(s, "Rodzaju") {
		t.Errorf("pl list missing Jana/Rodzaju:\n%s", s)
	}
}

func TestListFlag(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"--list"}, nil, &out, &errb); code != 0 {
		t.Fatalf("--list code=%d stderr=%q", code, errb.String())
	}
	if n := strings.Count(strings.TrimSpace(out.String()), "\n") + 1; n < 73 {
		t.Errorf("--list printed %d lines, want >=73", n)
	}
}

func TestRefEnglishDialect(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"-p", "Jn 3:16", "-b", "vul"}, nil, &out, &errb); code != 0 {
		t.Fatalf("ref code=%d stderr=%q", code, errb.String())
	}
	if !strings.Contains(out.String(), "3:16") {
		t.Errorf("ref output missing 3:16:\n%s", out.String())
	}
}

func TestRefRejectsPolishAbbrevInEnglish(t *testing.T) {
	var out, errb bytes.Buffer
	// English dialect (default): the Polish abbrev "Łk" must not resolve.
	if code := Run([]string{"-p", "Łk 3:16", "-b", "vul"}, nil, &out, &errb); code != 2 {
		t.Errorf("Łk in en dialect code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

func TestRefRejectsBT(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"-p", "Jn 3:16", "-b", "bt"}, nil, &out, &errb); code != 2 {
		t.Errorf("ref -b bt code=%d want 2 (stderr=%q)", code, errb.String())
	}
}

func TestRefCompare(t *testing.T) {
	var out, errb bytes.Buffer
	if code := Run([]string{"-p", "Jn 3:16", "-c", "vul,drb"}, nil, &out, &errb); code != 0 {
		t.Fatalf("ref compare code=%d stderr=%q", code, errb.String())
	}
	if !strings.Contains(out.String(), "3:16") {
		t.Errorf("ref compare missing verse:\n%s", out.String())
	}
}

func TestGospelCitationHelpers(t *testing.T) {
	secs := []liturgy.Section{
		{Heading: "1. czytanie (Iz 1, 1)", PartID: "pierwsze_czytanie"},
		{Heading: "Ewangelia (Mt 7, 1-5)", PartID: "ewangelia"},
	}
	sec, ok := gospelSection(secs)
	if !ok || sec.PartID != "ewangelia" {
		t.Fatalf("gospelSection=%+v ok=%v", sec, ok)
	}
	if c := gospelCitation(sec); c != "Mt 7, 1-5" {
		t.Errorf("citation from heading = %q", c)
	}
	// Citation field is preferred over the heading.
	s2 := liturgy.Section{Heading: "Ewangelia (Mt 7, 1-5)", Citation: "Mt 7, 1-5. 12", PartID: "ewangelia"}
	if c := gospelCitation(s2); c != "Mt 7, 1-5. 12" {
		t.Errorf("citation prefers Citation field, got %q", c)
	}
	// Empty -> ("", false).
	if _, ok := gospelSection(nil); ok {
		t.Error("gospelSection(nil) should be !ok")
	}
}

func TestCitation(t *testing.T) {
	html, err := os.ReadFile("../liturgy/testdata/2026-07-22.html")
	if err != nil {
		t.Fatal(err)
	}
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Write(html) }))
	defer srv.Close()
	liturgy.SetBaseURL(srv.URL + "/liturgia/%s/Ewangelia")
	t.Setenv("XDG_CACHE_HOME", t.TempDir())
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())

	var out, errb bytes.Buffer
	if code := Run([]string{"--citation", "2026-07-22"}, nil, &out, &errb); code != 0 {
		t.Fatalf("citation code=%d stderr=%q", code, errb.String())
	}
	if s := strings.TrimSpace(out.String()); !strings.Contains(s, "J 20") {
		t.Errorf("citation = %q, want a gospel ref containing 'J 20'", s)
	}
}

func TestWeek(t *testing.T) {
	html, err := os.ReadFile("../liturgy/testdata/2026-07-22.html")
	if err != nil {
		t.Fatal(err)
	}
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Write(html) }))
	defer srv.Close()
	liturgy.SetBaseURL(srv.URL + "/liturgia/%s/Ewangelia")
	t.Setenv("XDG_CACHE_HOME", t.TempDir())
	t.Setenv("XDG_CONFIG_HOME", t.TempDir())

	var out, errb bytes.Buffer
	if code := Run([]string{"--week", "2026-07-22"}, nil, &out, &errb); code != 0 {
		t.Fatalf("week code=%d stderr=%q", code, errb.String())
	}
	lines := strings.Split(strings.TrimSpace(out.String()), "\n")
	if len(lines) != 7 {
		t.Fatalf("week printed %d lines, want 7:\n%s", len(lines), out.String())
	}
	if !strings.HasPrefix(lines[0], "2026-07-22") || !strings.Contains(lines[0], "J 20") {
		t.Errorf("week[0] = %q", lines[0])
	}
}