package service

import (
	"context"
	"errors"
	"strings"
	"testing"

	"github.com/go-git/go-git/v5/plumbing"

	"sourcecraft.dev/bigbes/sr-ht-spec/authn"
	"sourcecraft.dev/bigbes/sr-ht-spec/core"
	"sourcecraft.dev/bigbes/sr-ht-spec/gitx"
)

func owner() authn.Principal {
	return authn.Principal{Kind: authn.KindOwner, Owner: "bigbes"}
}

func agent() authn.Principal {
	return authn.Principal{
		Kind: authn.KindAgent, Owner: "bigbes",
		Agent: "claude-code/spec-writer", Session: "8fb9c9a4",
	}
}

func TestValidateDocuments(t *testing.T) {
	schema := core.DefaultSchema()
	spec7 := Document{Path: "specs/0007.md", Blob: "a", Data: doc("SPEC-0007", "Storage", "body")}
	spec8 := Document{Path: "specs/0008.md", Blob: "b", Data: doc("SPEC-0008", "Other", "body")}
	dupe := Document{Path: "notes/copy.md", Blob: "c", Data: doc("SPEC-0007", "Copy", "body")}
	noStatus := Document{Path: "specs/0009.md", Blob: "d",
		Data: []byte("---\nid: SPEC-0009\ntitle: No status\n---\n\nbody\n")}
	noFrontmatter := Document{Path: "specs/0010.md", Blob: "e", Data: []byte("# just a heading\n")}
	badID := Document{Path: "specs/0011.md", Blob: "f",
		Data: doc("spec-11", "Lowercase id", "body")}

	tests := []struct {
		name     string
		all      []Document
		changed  []Document
		wantKind []PushProblemKind
		wantIn   []string
		wantRefs []string
	}{
		{
			name:     "clean push",
			all:      []Document{spec7, spec8},
			changed:  []Document{spec8},
			wantRefs: []string{"SPEC-0008"},
		},
		{
			name:     "missing required key",
			all:      []Document{noStatus},
			changed:  []Document{noStatus},
			wantKind: []PushProblemKind{ProblemFrontmatter},
			wantIn:   []string{"status"},
		},
		{
			name:     "no frontmatter at all",
			all:      []Document{noFrontmatter},
			changed:  []Document{noFrontmatter},
			wantKind: []PushProblemKind{ProblemFrontmatter},
			wantIn:   []string{"frontmatter"},
		},
		{
			name:     "malformed id",
			all:      []Document{badID},
			changed:  []Document{badID},
			wantKind: []PushProblemKind{ProblemFrontmatter},
			wantIn:   []string{"document id"},
		},
		{
			// The failure mode the whole escape hatch exists to guard: a
			// duplicated id: corrupts the global registry.
			name:     "duplicate id introduced by this push",
			all:      []Document{dupe, spec7},
			changed:  []Document{dupe},
			wantKind: []PushProblemKind{ProblemDuplicateID},
			wantIn:   []string{"SPEC-0007", "specs/0007.md"},
			wantRefs: []string{"SPEC-0007"},
		},
		{
			// Both halves of the collision were already there, pushed under
			// skip-validation. Rejecting every later push would turn a
			// cosmetic error into a lockout — and the fix unpushable.
			name:     "pre-existing duplicate untouched by this push",
			all:      []Document{dupe, spec7, spec8},
			changed:  []Document{spec8},
			wantRefs: []string{"SPEC-0008"},
		},
		{
			// A malformed document already on the branch is tolerated, not
			// fatal: it must not block every future push.
			name:     "malformed document not part of this push",
			all:      []Document{noFrontmatter, spec8},
			changed:  []Document{spec8},
			wantRefs: []string{"SPEC-0008"},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			problems, refs := validateDocuments(tc.all, tc.changed, schema)
			if len(problems) != len(tc.wantKind) {
				t.Fatalf("problems = %+v, want %d", problems, len(tc.wantKind))
			}
			for i, kind := range tc.wantKind {
				if problems[i].Kind != kind {
					t.Errorf("problem %d kind = %q, want %q", i, problems[i].Kind, kind)
				}
			}
			for _, want := range tc.wantIn {
				found := false
				for _, p := range problems {
					if strings.Contains(p.Detail, want) {
						found = true
					}
				}
				if !found {
					t.Errorf("no problem mentions %q: %+v", want, problems)
				}
			}
			var got []string
			for _, r := range refs {
				got = append(got, r.ID.String())
			}
			if strings.Join(got, ",") != strings.Join(tc.wantRefs, ",") {
				t.Errorf("refs = %v, want %v", got, tc.wantRefs)
			}
		})
	}
}

// The message is what a human reads in their terminal after a rejected push, so
// it is a product surface and is asserted as one.
func TestPushRejectionMessage(t *testing.T) {
	rej := &PushRejection{
		Space: fxSpace,
		Ref:   "refs/heads/main",
		Problems: []PushProblem{
			{Kind: ProblemFrontmatter, Path: "specs/0007.md",
				Detail: `missing required frontmatter field: "status"`},
			{Kind: ProblemIDCollision, Path: "notes/x.md",
				Detail: "id RFC-0001 is already registered to ~bigbes/notes at rfcs/0001.md"},
		},
		Skippable: true,
	}
	msg := rej.Error()
	for _, want := range []string{
		"~bigbes/rfcs", "refs/heads/main",
		"specs/0007.md", `missing required frontmatter field: "status"`,
		"notes/x.md", "RFC-0001", "~bigbes/notes",
		"2 problems", "--push-option=skip-validation",
	} {
		if !strings.Contains(msg, want) {
			t.Errorf("message does not contain %q:\n%s", want, msg)
		}
	}
	if !errors.Is(rej, ErrPushRejected) {
		t.Error("rejection does not satisfy errors.Is(err, ErrPushRejected)")
	}
	for _, line := range strings.Split(msg, "\n") {
		if len(line) > 72 {
			t.Errorf("line is %d chars, too long once git prefixes it with %q: %s",
				len(line), "remote: ", line)
		}
	}
}

// A refs-rule rejection must not suggest a flag that will not help.
func TestPushRejectionNeverOffersToSkipTheRefsRule(t *testing.T) {
	rej := &PushRejection{
		Space:    fxSpace,
		Ref:      "refs/heads/main",
		Problems: []PushProblem{{Kind: ProblemRefsRule, Detail: "agents may only write proposals/*"}},
	}
	msg := rej.Error()
	if strings.Contains(msg, "Re-push with") {
		t.Errorf("refs-rule rejection offers the escape hatch:\n%s", msg)
	}
	if !strings.Contains(msg, "cannot be bypassed") {
		t.Errorf("refs-rule rejection does not say the rule is absolute:\n%s", msg)
	}
	if !strings.Contains(msg, "1 problem") {
		t.Errorf("singular problem count is wrong:\n%s", msg)
	}
}

func TestParseObjectName(t *testing.T) {
	tests := []struct {
		in      string
		wantErr bool
		wantNil bool // resolves to the zero object name
	}{
		{in: "", wantNil: true},
		{in: zeroObjectName, wantNil: true},
		{in: "1f0c1d1a1e2b3c4d5e6f708192a3b4c5d6e7f809"},
		{in: "1f0c1d1a", wantErr: true},
		{in: "1f0c1d1a1e2b3c4d5e6f708192a3b4c5d6e7f80z", wantErr: true},
		{in: "refs/heads/main", wantErr: true},
	}
	for _, tc := range tests {
		got, err := parseObjectName("new", tc.in)
		if tc.wantErr != (err != nil) {
			t.Errorf("parseObjectName(%q) err = %v, wantErr %v", tc.in, err, tc.wantErr)
			continue
		}
		if err == nil && got.IsZero() != tc.wantNil {
			t.Errorf("parseObjectName(%q) = %s, wantZero %v", tc.in, got, tc.wantNil)
		}
	}
}

// Anonymous must not default to either principal: there is no unauthenticated
// write path, and mapping it to "agent" would hand it the proposal namespace.
func TestPrincipalKind(t *testing.T) {
	if got, err := principalKind(owner()); err != nil || got != gitx.PrincipalHuman {
		t.Errorf("owner -> %q, %v", got, err)
	}
	if got, err := principalKind(agent()); err != nil || got != gitx.PrincipalAgent {
		t.Errorf("agent -> %q, %v", got, err)
	}
	if _, err := principalKind(authn.Anonymous()); err == nil {
		t.Error("anonymous resolved to a writing principal")
	}
}

func TestCheckRefsRule(t *testing.T) {
	svc, root := newService(t)
	sp := newSpace(t, root, 1)
	ctx := context.Background()

	first := commitFiles(t, sp, sp.ApprovedBranch(), 1, map[string][]byte{
		"specs/0007.md": doc("SPEC-0007", "Storage", "one"),
	})
	second := commitFiles(t, sp, sp.ApprovedBranch(), 2, map[string][]byte{
		"specs/0007.md": doc("SPEC-0007", "Storage", "two"),
	})
	cutBranch(t, sp, "proposals/1", sp.ApprovedBranch())
	branch := commitFiles(t, sp, "proposals/1", 3, map[string][]byte{
		"specs/0008.md": doc("SPEC-0008", "Other", "one"),
	})

	tests := []struct {
		name      string
		principal authn.Principal
		ref       string
		old, new  string
		wantOK    bool
	}{
		{"owner fast-forwards the approved branch", owner(), "refs/heads/main",
			first.String(), second.String(), true},
		{"owner force-pushes the approved branch", owner(), "refs/heads/main",
			second.String(), first.String(), false},
		{"owner deletes the approved branch", owner(), "refs/heads/main",
			second.String(), zeroObjectName, false},
		{"agent moves the approved branch", agent(), "refs/heads/main",
			first.String(), second.String(), false},
		{"agent writes a proposal branch", agent(), "refs/heads/proposals/1",
			zeroObjectName, branch.String(), true},
		{"agent force-updates its own proposal branch", agent(), "refs/heads/proposals/1",
			branch.String(), first.String(), true},
		{"owner pushes a tag", owner(), "refs/tags/v1", zeroObjectName, second.String(), false},
		{"owner pushes an unrelated branch", owner(), "refs/heads/scratch",
			zeroObjectName, second.String(), false},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			old, err := parseObjectName("old", tc.old)
			if err != nil {
				t.Fatal(err)
			}
			newHash, err := parseObjectName("new", tc.new)
			if err != nil {
				t.Fatal(err)
			}
			problem := svc.checkRefsRule(ctx, sp, PushRequest{
				Principal: tc.principal, Ref: tc.ref,
			}, old, newHash)
			if tc.wantOK != (problem == nil) {
				t.Fatalf("problem = %+v, wantOK %v", problem, tc.wantOK)
			}
			if problem != nil && problem.Kind != ProblemRefsRule {
				t.Errorf("kind = %q", problem.Kind)
			}
		})
	}
}

// A new proposal branch is compared against the approved head, not against
// nothing: comparing against nothing would revalidate the whole space and let
// one skip-validation typo block every future proposal branch.
func TestChangedDocumentsBaselinesANewBranchOnTheApprovedHead(t *testing.T) {
	svc, root := newService(t)
	sp := newSpace(t, root, 1)
	ctx := context.Background()

	commitFiles(t, sp, sp.ApprovedBranch(), 1, map[string][]byte{
		"specs/0007.md": doc("SPEC-0007", "Storage", "one"),
		"specs/0009.md": []byte("not a document at all\n"),
	})
	cutBranch(t, sp, "proposals/1", sp.ApprovedBranch())
	branch := commitFiles(t, sp, "proposals/1", 2, map[string][]byte{
		"specs/0008.md": doc("SPEC-0008", "Other", "one"),
	})

	all, changed, err := svc.changedDocuments(ctx, sp, zeroHash(t), branch)
	if err != nil {
		t.Fatalf("changedDocuments: %v", err)
	}
	if len(all) != 3 {
		t.Errorf("all = %d documents, want 3", len(all))
	}
	if len(changed) != 1 || changed[0].Path != "specs/0008.md" {
		t.Fatalf("changed = %+v, want only specs/0008.md", changed)
	}
}

func TestChangedDocumentsUsesTheOldRefValueWhenThereIsOne(t *testing.T) {
	svc, root := newService(t)
	sp := newSpace(t, root, 1)
	ctx := context.Background()

	old := commitFiles(t, sp, sp.ApprovedBranch(), 1, map[string][]byte{
		"specs/0007.md": doc("SPEC-0007", "Storage", "one"),
		"specs/0008.md": doc("SPEC-0008", "Other", "one"),
	})
	newHead := commitFiles(t, sp, sp.ApprovedBranch(), 2, map[string][]byte{
		"specs/0008.md": doc("SPEC-0008", "Other", "two"),
	})

	_, changed, err := svc.changedDocuments(ctx, sp, old, newHead)
	if err != nil {
		t.Fatalf("changedDocuments: %v", err)
	}
	if len(changed) != 1 || changed[0].Path != "specs/0008.md" {
		t.Fatalf("changed = %+v, want only specs/0008.md", changed)
	}
}

func zeroHash(t *testing.T) plumbing.Hash {
	t.Helper()
	h, err := parseObjectName("old", "")
	if err != nil {
		t.Fatal(err)
	}
	return h
}