package checker

import (
	"encoding/json"
	"strings"
	"testing"

	sdk "git.happydns.org/checker-sdk-go/checker"
)

func TestStatesToFindings(t *testing.T) {
	states := []sdk.CheckState{
		{Status: sdk.StatusOK, Code: "ok"},
		{Status: sdk.StatusInfo, Code: "i", Subject: "ex./A", Message: "info"},
		{Status: sdk.StatusWarn, Code: "w", Subject: "ex./A", Message: "warn"},
		{Status: sdk.StatusCrit, Code: "c", Subject: "ex./A", Message: "crit"},
	}
	got := statesToFindings(states)
	if len(got) != 3 {
		t.Errorf("expected 3 findings (OK skipped), got %d: %+v", len(got), got)
	}
	severities := map[Severity]bool{}
	for _, f := range got {
		severities[f.Severity] = true
	}
	if !severities[SeverityCrit] || !severities[SeverityWarn] || !severities[SeverityInfo] {
		t.Errorf("missing some severities: %+v", got)
	}
}

func TestSeverityFromStatus(t *testing.T) {
	cases := []struct {
		in     sdk.Status
		want   Severity
		wantOK bool
	}{
		{sdk.StatusCrit, SeverityCrit, true},
		{sdk.StatusWarn, SeverityWarn, true},
		{sdk.StatusInfo, SeverityInfo, true},
		{sdk.StatusOK, "", false},
	}
	for _, c := range cases {
		got, ok := severityFromStatus(c.in)
		if got != c.want || ok != c.wantOK {
			t.Errorf("severityFromStatus(%v) = (%v,%v), want (%v,%v)", c.in, got, ok, c.want, c.wantOK)
		}
	}
}

func TestSeverityRank(t *testing.T) {
	if severityRank(SeverityCrit) <= severityRank(SeverityWarn) {
		t.Errorf("crit should outrank warn")
	}
	if severityRank(SeverityWarn) <= severityRank(SeverityInfo) {
		t.Errorf("warn should outrank info")
	}
}

func TestRemedyFor(t *testing.T) {
	// known code returns a non-empty hint
	if r := remedyFor(CodeAnswerDrift); r == "" {
		t.Errorf("expected remedy for %q", CodeAnswerDrift)
	}
	// unknown code is allowed to be empty
	_ = remedyFor("totally-bogus-code-xyz")
}

func TestIsResolverScopedCode(t *testing.T) {
	if !isResolverScopedCode(CodeResolverUnreachable) {
		t.Errorf("resolver code should be scoped")
	}
	if isResolverScopedCode(CodeAnswerDrift) {
		t.Errorf("rrset code should not be scoped")
	}
}

func TestGetHTMLReport_Smoke(t *testing.T) {
	key := "ex./A"
	data := &ResolverPropagationData{
		Zone:  "ex.",
		Names: []string{"ex."},
		Types: []string{"A"},
		Resolvers: map[string]*ResolverView{
			"a": mkResolver("a", "eu", false, true, map[string]*RRProbe{
				key: {Rcode: "NOERROR", Signature: "1.1.1.1", Records: []string{"1.1.1.1"}, LatencyMs: 30, Transport: TransportUDP},
			}),
			"b": mkResolver("b", "global", false, true, map[string]*RRProbe{
				key: {Rcode: "NOERROR", Signature: "1.1.1.1", Records: []string{"1.1.1.1"}, LatencyMs: 40, Transport: TransportUDP},
			}),
		},
		RRsets: map[string]*RRsetView{key: {Name: "ex.", Type: "A"}},
		Stats:  Stats{TotalResolvers: 2, ReachableResolvers: 2, UnfilteredProbed: 2},
	}
	raw, err := json.Marshal(data)
	if err != nil {
		t.Fatalf("marshal: %v", err)
	}
	ctx := sdk.NewReportContext(raw, nil, []sdk.CheckState{
		{Status: sdk.StatusOK, Code: "ok", Message: "fine"},
	})

	prov := &resolverPropagationProvider{}
	html, err := prov.GetHTMLReport(ctx)
	if err != nil {
		t.Fatalf("GetHTMLReport: %v", err)
	}
	for _, want := range []string{"ex.", "1.1.1.1", "Europe", "Global"} {
		if !strings.Contains(html, want) {
			t.Errorf("HTML report missing %q", want)
		}
	}
}

func TestGetHTMLReport_BadPayload(t *testing.T) {
	ctx := sdk.StaticReportContext(json.RawMessage(`not-json`))
	prov := &resolverPropagationProvider{}
	if _, err := prov.GetHTMLReport(ctx); err == nil {
		t.Errorf("want decode error")
	}
}

func TestGetHTMLReport_EmptyPayload(t *testing.T) {
	ctx := sdk.StaticReportContext(nil)
	prov := &resolverPropagationProvider{}
	if _, err := prov.GetHTMLReport(ctx); err != nil {
		t.Errorf("empty payload should not error, got %v", err)
	}
}