package txlog

import (
	"bytes"
	"encoding/json"
	"errors"
	"strings"
	"sync"
	"testing"
	"time"

	"migadu_counters/internal/counting"
	"migadu_counters/internal/domains"
	"migadu_counters/internal/notify"
)

var clock = time.Date(2026, 10, 6, 1, 12, 6, 412_000_000, time.UTC)

const ts = "2026-10-06 01:12:06.412"

type table map[string]*domains.Domain

func (t table) Lookup(d string) (*domains.Domain, error) {
	if r, ok := t[d]; ok {
		return r, nil
	}
	return nil, domains.ErrNotFound
}

func planner() *counting.Planner {
	return &counting.Planner{
		Lookup: table{
			"wearemiraclesnow.com": {Name: "wearemiraclesnow.com", OrgID: 116681,
				Limits: domains.ParseLimits("O/i=10000,O/o=2200,D/i=10000,D/o=2200,A/i=500,A/o=100")},
			"nolimits.net": {Name: "nolimits.net", OrgID: 11, Limits: domains.Limits{}},
			"many.example": {Name: "many.example", OrgID: 5,
				Limits: domains.ParseLimits("A/i=1,A/o=2,bob@/i=3,bob@/o=4,carol@/i=5,dave@/o=6")},
		},
		Exempt: map[string]bool{"support@migadu.com": true},
		Now:    func() time.Time { return clock },
	}
}

// outcome executes nothing: it attaches the given counts to the plan, with
// Reached derived exactly as Counter does.
func outcome(plan *counting.Plan, counts ...int64) *counting.Outcome {
	out := &counting.Outcome{Plan: plan}
	for i, inc := range plan.Increments {
		out.Results = append(out.Results, counting.Result{
			Increment: inc, Count: counts[i],
			Reached: inc.Limited && counting.Crossed(counts[i], 1, inc.Limit),
		})
	}
	return out
}

func newLogger(format string) (*Logger, *bytes.Buffer) {
	var buf bytes.Buffer
	return New(&buf, format, func() time.Time { return clock }), &buf
}

func TestOutcome_OutText(t *testing.T) {
	plan, err := planner().PlanOut("ad8525", "noah@wearemiraclesnow.com", "noah@wearemiraclesnow.com", "y@example.org")
	if err != nil {
		t.Fatal(err)
	}
	l, buf := newLogger("text")
	l.Outcome(outcome(plan, 12, 1830, 2200), []bool{false, false, true})

	want := strings.Join([]string{
		ts + " <ad8525> out; request auth_user=noah@wearemiraclesnow.com recipient=y@example.org mail_from=noah@wearemiraclesnow.com",
		ts + " <ad8525> out; local domain: wearemiraclesnow.com account_id=116681",
		ts + " <ad8525> out; domain: wearemiraclesnow.com limits_map={A/i=500, A/o=100, D/i=10000, D/o=2200, O/i=10000, O/o=2200}",
		ts + " <ad8525> out; determined limit (level=[A] flow=[o] key=[cnt/A/noah@wearemiraclesnow.com/d/2026-10-06/o]) => 100",
		ts + " <ad8525> out; determined limit (level=[D] flow=[o] key=[cnt/D/wearemiraclesnow.com/d/2026-10-06/o]) => 2200",
		ts + " <ad8525> out; determined limit (level=[O] flow=[o] key=[cnt/O/116681/d/2026-10-06/o]) => 2200",
		ts + " <ad8525> out; recipient domain not in domains db: example.org (not counted)",
		ts + " <ad8525> out; tracked address counters for noah@wearemiraclesnow.com => count=12 limit=100 reached=false",
		ts + " <ad8525> out; tracked domain counters for wearemiraclesnow.com => count=1830 limit=2200 reached=false",
		ts + " <ad8525> out; tracked account counters for 116681 => count=2200 limit=2200 reached=true",
		ts + " <ad8525> out; limit reached (level=[O] id=[116681] flow=[o] by=[noah@wearemiraclesnow.com]) => notifying org_url",
		"",
	}, "\n")
	if got := buf.String(); got != want {
		t.Errorf("block mismatch\n--- got ---\n%s--- want ---\n%s", got, want)
	}
}

func TestOutcome_InTextUnlimited(t *testing.T) {
	plan, err := planner().PlanIn("tr2", "s@gmail.com", "q@nolimits.net", false)
	if err != nil {
		t.Fatal(err)
	}
	l, buf := newLogger("text")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	want := strings.Join([]string{
		ts + " <tr2> in; request mail_from=s@gmail.com recipient=q@nolimits.net junk=false",
		ts + " <tr2> in; local domain: nolimits.net account_id=11",
		ts + " <tr2> in; domain: nolimits.net limits_map={}",
		ts + " <tr2> in; determined limit (level=[A] flow=[i] key=[cnt/A/q@nolimits.net/d/2026-10-06/i]) => unlimited",
		ts + " <tr2> in; determined limit (level=[D] flow=[i] key=[cnt/D/nolimits.net/d/2026-10-06/i]) => unlimited",
		ts + " <tr2> in; determined limit (level=[O] flow=[i] key=[cnt/O/11/d/2026-10-06/i]) => unlimited",
		ts + " <tr2> in; tracked address counters for q@nolimits.net => count=1 limit=unlimited reached=false",
		ts + " <tr2> in; tracked domain counters for nolimits.net => count=1 limit=unlimited reached=false",
		ts + " <tr2> in; tracked account counters for 11 => count=1 limit=unlimited reached=false",
		"",
	}, "\n")
	if got := buf.String(); got != want {
		t.Errorf("block mismatch\n--- got ---\n%s--- want ---\n%s", got, want)
	}
}

func TestOutcome_ReachedWithoutURL(t *testing.T) {
	plan, _ := planner().PlanIn("tr", "s@gmail.com", "y@wearemiraclesnow.com", false)
	l, buf := newLogger("text")
	// D/i=10000 reached, A and O not; domain_url not configured -> dispatched false.
	l.Outcome(outcome(plan, 3, 10000, 9), []bool{false, false, false})
	want := ts + " <tr> in; limit reached (level=[D] id=[wearemiraclesnow.com] flow=[i] by=[y@wearemiraclesnow.com]) => no domain_url configured, not notifying\n"
	if got := buf.String(); !strings.HasSuffix(got, want) {
		t.Errorf("missing not-notifying line\n--- got ---\n%s--- want suffix ---\n%s", got, want)
	}
	if strings.Count(buf.String(), "limit reached") != 1 {
		t.Errorf("want exactly one limit reached line:\n%s", buf.String())
	}
}

func TestOutcome_Skips(t *testing.T) {
	p := planner()
	cases := []struct {
		name string
		plan func() (*counting.Plan, error)
		want []string
	}{
		{"exempt", func() (*counting.Plan, error) {
			return p.PlanIn("t", "support@migadu.com", "y@wearemiraclesnow.com", false)
		},
			[]string{
				ts + " <t> in; request mail_from=support@migadu.com recipient=y@wearemiraclesnow.com junk=false",
				ts + " <t> in; skipped: exempt",
			}},
		{"junk", func() (*counting.Plan, error) { return p.PlanIn("t", "s@gmail.com", "y@wearemiraclesnow.com", true) },
			[]string{
				ts + " <t> in; request mail_from=s@gmail.com recipient=y@wearemiraclesnow.com junk=true",
				ts + " <t> in; skipped: junk",
			}},
		{"unknown", func() (*counting.Plan, error) { return p.PlanOut("t", "a@unknown.tld", "", "b@gmail.com") },
			[]string{
				ts + " <t> out; request auth_user=a@unknown.tld recipient=b@gmail.com mail_from=",
				ts + " <t> out; sender domain not in domains db: unknown.tld (not counted)",
				ts + " <t> out; recipient domain not in domains db: gmail.com (not counted)",
				ts + " <t> out; skipped: unknown_domain",
			}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			plan, err := c.plan()
			if err != nil {
				t.Fatal(err)
			}
			l, buf := newLogger("text")
			l.Outcome(outcome(plan), nil)
			if got, want := buf.String(), strings.Join(c.want, "\n")+"\n"; got != want {
				t.Errorf("--- got ---\n%s--- want ---\n%s", got, want)
			}
		})
	}
}

func TestFailed_RedisError(t *testing.T) {
	plan, _ := planner().PlanIn("tr", "s@gmail.com", "y@wearemiraclesnow.com", false)
	l, buf := newLogger("text")
	l.Failed(plan, errors.New("redis incr: dial tcp 127.0.0.1:6379: connect: connection refused"))
	got := buf.String()
	if !strings.HasPrefix(got, ts+" <tr> in; request mail_from=s@gmail.com") {
		t.Errorf("missing request line:\n%s", got)
	}
	if !strings.Contains(got, "determined limit (level=[O]") {
		t.Errorf("lookup trail missing before the error:\n%s", got)
	}
	if !strings.HasSuffix(got, ts+" <tr> in; redis error: redis incr: dial tcp 127.0.0.1:6379: connect: connection refused (nothing counted)\n") {
		t.Errorf("missing error line:\n%s", got)
	}
	if strings.Contains(got, "tracked") {
		t.Errorf("no tracked lines expected when nothing was counted:\n%s", got)
	}
}

func TestNotificationLines(t *testing.T) {
	l, buf := newLogger("text")
	ev := notify.Event{TraceID: "ad8525", Route: "out", Level: "O", ID: "116681", Flow: "o", Address: "noah@wearemiraclesnow.com", Count: 2200, Limit: 2200}
	u := "https://admin.migadu.com/api/limits?level=O&id=116681&flow=o&period=d&by=noah%40wearemiraclesnow.com&count=2200"
	l.NotificationSent(ev, u, 1)
	l.NotificationFailed(ev, u, 5, errors.New("unexpected status 500"))
	want := ts + ` <ad8525> out; sent limit exceeded notification to url "` + u + `"` + "\n" +
		ts + ` <ad8525> out; failed limit exceeded notification to url "` + u + `" after 5 attempts: unexpected status 500` + "\n"
	if got := buf.String(); got != want {
		t.Errorf("--- got ---\n%s--- want ---\n%s", got, want)
	}
}

func TestEmptyTraceID(t *testing.T) {
	plan, _ := planner().PlanIn("", "s@gmail.com", "y@wearemiraclesnow.com", true)
	l, buf := newLogger("text")
	l.Outcome(outcome(plan), nil)
	if !strings.HasPrefix(buf.String(), ts+" <-> in; request") {
		t.Errorf("empty trace id should print as <->:\n%s", buf.String())
	}
}

// Domains with thousands of per-address overrides (boxmailhere.com has 9 798)
// must not dump them all: base keys + the address's own overrides + a count.
func TestLimitsMapSummarised(t *testing.T) {
	plan, _ := planner().PlanOut("t", "bob@many.example", "", "ext@gmail.com")
	l, buf := newLogger("text")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	want := ts + " <t> out; domain: many.example limits_map={A/i=1, A/o=2, bob@/i=3, bob@/o=4} (+2 other overrides)\n"
	if !strings.Contains(buf.String(), want) {
		t.Errorf("--- got ---\n%s--- want line ---\n%s", buf.String(), want)
	}
}

func TestOutcome_JSON(t *testing.T) {
	plan, _ := planner().PlanOut("ad8525", "noah@wearemiraclesnow.com", "noah@wearemiraclesnow.com", "y@example.org")
	l, buf := newLogger("json")
	l.Outcome(outcome(plan, 12, 1830, 2200), []bool{false, false, true})

	lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
	var events []string
	var records []map[string]any
	for _, line := range lines {
		var rec map[string]any
		if err := json.Unmarshal([]byte(line), &rec); err != nil {
			t.Fatalf("line is not JSON: %q: %v", line, err)
		}
		if rec["trace_id"] != "ad8525" || rec["route"] != "out" || rec["ts"] != "2026-10-06T01:12:06.412Z" {
			t.Errorf("common fields wrong: %v", rec)
		}
		events = append(events, rec["event"].(string))
		records = append(records, rec)
	}
	wantEvents := []string{"request", "local_domain", "limits", "determined_limit", "determined_limit", "determined_limit",
		"not_in_db", "tracked", "tracked", "tracked", "limit_reached"}
	if strings.Join(events, ",") != strings.Join(wantEvents, ",") {
		t.Errorf("events = %v\nwant %v", events, wantEvents)
	}
	o := records[9]
	if o["level"] != "O" || o["id"] != "116681" || o["count"].(float64) != 2200 || o["limit"].(float64) != 2200 || o["reached"] != true ||
		o["key"] != "cnt/O/116681/d/2026-10-06/o" || o["flow"] != "o" {
		t.Errorf("tracked O record = %v", o)
	}
	if r := records[10]; r["notifying"] != true || r["url_name"] != "org_url" || r["by"] != "noah@wearemiraclesnow.com" {
		t.Errorf("limit_reached record = %v", r)
	}
	if r := records[1]; r["domain"] != "wearemiraclesnow.com" || r["org_id"].(float64) != 116681 {
		t.Errorf("local_domain record = %v", r)
	}
}

// countingWriter counts Write calls: each block must be one write so
// concurrent requests never interleave their lines.
type countingWriter struct {
	mu     sync.Mutex
	writes int
	buf    bytes.Buffer
}

func (w *countingWriter) Write(p []byte) (int, error) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.writes++
	return w.buf.Write(p)
}

func TestBlockIsSingleWrite(t *testing.T) {
	w := &countingWriter{}
	l := New(w, "text", func() time.Time { return clock })
	plan, _ := planner().PlanOut("t", "noah@wearemiraclesnow.com", "", "y@wearemiraclesnow.com")
	l.Outcome(outcome(plan, 1, 1, 1, 1, 1, 1), nil)
	l.Failed(plan, errors.New("x"))
	l.NotificationSent(notify.Event{}, "u", 1)
	if w.writes != 3 {
		t.Errorf("writes = %d, want 3 (one per block/line)", w.writes)
	}
}

func TestErrorLine(t *testing.T) {
	l, buf := newLogger("text")
	l.Error("out", "tr", errors.New("lookup sender domain x.com: cdb read error"))
	want := ts + " <tr> out; error: lookup sender domain x.com: cdb read error (nothing counted)\n"
	if got := buf.String(); got != want {
		t.Errorf("got %q, want %q", got, want)
	}
}

// --- review round 1 lines -----------------------------------------------------

func TestRequestLine_LoginSuffixAndUnusable(t *testing.T) {
	plan, err := planner().Plan(counting.Job{Route: counting.RouteOut, TraceID: "m1", AuthUser: "x@wearemiraclesnow.com", LoginSuffix: "SUPPORTTOKEN",
		MailFrom: "x@wearemiraclesnow.com", MailFromUsable: true,
		RecipientUnusable: counting.Unusable{Role: "recipient", Value: "u@[192.0.2.1]", Reason: "invalid e-mail address"}})
	if err != nil {
		t.Fatal(err)
	}
	l, buf := newLogger("text")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	got := buf.String()
	if !strings.Contains(got, ts+" <m1> out; request auth_user=x@wearemiraclesnow.com recipient= mail_from=x@wearemiraclesnow.com login_suffix=SUPPORTTOKEN\n") {
		t.Errorf("request line should show the login suffix:\n%s", got)
	}
	if !strings.Contains(got, ts+" <m1> out; recipient address not usable: u@[192.0.2.1] (invalid e-mail address, not counted)\n") {
		t.Errorf("missing unusable line:\n%s", got)
	}
	if !strings.Contains(got, "tracked address counters for x@wearemiraclesnow.com => count=1") {
		t.Errorf("sender should still be tracked:\n%s", got)
	}

	plan, _ = planner().Plan(counting.Job{Route: counting.RouteOut, TraceID: "m2", Recipient: "y@wearemiraclesnow.com",
		SenderUnusable: counting.Unusable{Role: "sender", Reason: "missing"}})
	l, buf = newLogger("text")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	if got := buf.String(); !strings.Contains(got, " <m2> out; sender address not usable: <empty> (missing, not counted)\n") || strings.Contains(got, "login_suffix") {
		t.Errorf("missing sender line / unexpected suffix:\n%s", got)
	}

	l, buf = newLogger("json")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	if got := buf.String(); !strings.Contains(got, `"event":"not_usable"`) || !strings.Contains(got, `"role":"sender"`) || !strings.Contains(got, `"reason":"missing"`) {
		t.Errorf("json not_usable event missing:\n%s", got)
	}
}

// A key whose own INCR failed gets an error line instead of a tracked line;
// the other keys are tracked normally.
func TestOutcome_PerKeyError(t *testing.T) {
	plan, _ := planner().PlanOut("p1", "noah@wearemiraclesnow.com", "", "s@gmail.com")
	out := outcome(plan, 100, 1830, 0)
	out.Results[2].Err = errors.New("redis incr cnt/O/116681/d/2026-10-06/o: ERR value is not an integer or out of range")
	l, buf := newLogger("text")
	l.Outcome(out, []bool{true, false, false})
	got := buf.String()
	if !strings.Contains(got, ts+" <p1> out; tracked address counters for noah@wearemiraclesnow.com => count=100 limit=100 reached=true\n") {
		t.Errorf("A should be tracked and reached:\n%s", got)
	}
	if !strings.Contains(got, ts+" <p1> out; redis error on key cnt/O/116681/d/2026-10-06/o: redis incr cnt/O/116681/d/2026-10-06/o: ERR value is not an integer or out of range (not counted)\n") {
		t.Errorf("missing per-key error line:\n%s", got)
	}
	if strings.Contains(got, "tracked account counters") {
		t.Errorf("failed key must not be reported as tracked:\n%s", got)
	}
}

// A lost EXEC reply: the counts come from a master re-read and the block says so.
func TestOutcome_UnknownReRead(t *testing.T) {
	plan, _ := planner().PlanOut("u1", "noah@wearemiraclesnow.com", "", "s@gmail.com")
	out := outcome(plan, 100, 1830, 2200)
	out.Unknown = errors.New("redis incr: read tcp 10.0.0.1:1->10.0.0.2:6379: i/o timeout")
	l, buf := newLogger("text")
	l.Outcome(out, []bool{true, false, true})
	got := buf.String()
	if !strings.Contains(got, ts+" <u1> out; redis outcome unknown: redis incr: read tcp 10.0.0.1:1->10.0.0.2:6379: i/o timeout, re-read from master\n") {
		t.Errorf("missing unknown-outcome line:\n%s", got)
	}
	if !strings.Contains(got, "tracked address counters for noah@wearemiraclesnow.com => count=100 limit=100 reached=true (re-read)\n") {
		t.Errorf("tracked lines should be marked re-read:\n%s", got)
	}
	if !strings.Contains(got, "limit reached (level=[A]") {
		t.Errorf("crossing after re-read should still be reported:\n%s", got)
	}
	if strings.Contains(got, "nothing counted") {
		t.Errorf("an unknown outcome is not 'nothing counted':\n%s", got)
	}
	l, buf = newLogger("json")
	l.Outcome(out, nil)
	if got := buf.String(); !strings.Contains(got, `"event":"redis_unknown"`) || !strings.Contains(got, `"reread":true`) {
		t.Errorf("json unknown event missing:\n%s", got)
	}
}

func TestDropped(t *testing.T) {
	l, buf := newLogger("text")
	l.Dropped(counting.RouteIn, "d1")
	if got := buf.String(); got != ts+" <d1> in; dropped: queue full (not counted)\n" {
		t.Errorf("got %q", got)
	}
	l, buf = newLogger("json")
	l.Dropped(counting.RouteOut, "d2")
	if got := buf.String(); !strings.Contains(got, `"event":"dropped"`) || !strings.Contains(got, `"route":"out"`) {
		t.Errorf("got %q", got)
	}
}

func TestTrail_MalformedRow(t *testing.T) {
	bad := table{"good.com": {Name: "good.com", OrgID: 7, Limits: domains.ParseLimits("A/o=5")}}
	p := &counting.Planner{Lookup: malformedTable{bad}, Now: func() time.Time { return clock }}
	plan, err := p.PlanOut("mf", "a@good.com", "", "b@bad.com")
	if err != nil {
		t.Fatal(err)
	}
	l, buf := newLogger("text")
	l.Outcome(outcome(plan, 1, 1, 1), nil)
	if !strings.Contains(buf.String(), ts+" <mf> out; recipient domain row malformed in domains db: bad.com: "+`domain bad.com: invalid org id "x12"`+" (not counted)\n") {
		t.Errorf("missing malformed line:\n%s", buf.String())
	}
}

type malformedTable struct{ table }

func (m malformedTable) Lookup(d string) (*domains.Domain, error) {
	if d == "bad.com" {
		return domains.ParseRecord("bad.com", "x12|A/i=5")
	}
	return m.table.Lookup(d)
}