package store

import (
	"encoding/json"
	"errors"
	"testing"
	"time"

	"orchestra/internal/authz"
	"orchestra/internal/domain"
)

func decisionPayload(t *testing.T, id, kind, subject, value string, supersedes ...string) []byte {
	t.Helper()
	p := map[string]any{
		"decision_id": id, "kind": kind, "subject": subject, "value": value,
		"source": map[string]any{"provider": "gitea", "external_id": "issue-1#c7"},
	}
	if len(supersedes) > 0 {
		p["supersedes"] = supersedes
	}
	b, err := json.Marshal(p)
	if err != nil {
		t.Fatal(err)
	}
	return b
}

// A decision must land while the task is leased — that is the whole point,
// since the human corrects work already in flight — without touching task
// state or the current lease.
func TestDecisionAppendsUnderLiveLeaseWithoutDisturbingProjection(t *testing.T) {
	dir := t.TempDir()
	s, err := Open(dir)
	if err != nil {
		t.Fatal(err)
	}
	if err := s.Append(created("create")); err != nil {
		t.Fatal(err)
	}
	if _, err := s.Lease("task-1", "h1", time.Minute); err != nil {
		t.Fatal(err)
	}
	before, _ := s.Task("task-1")

	e := domain.Event{
		ID: "e-d1", Type: domain.EventHumanDecisionRecorded, TaskID: "task-1",
		Version: before.Version + 1, At: time.Now().UTC(),
		Payload: decisionPayload(t, "d1", "correction", "strategy", "use b"),
		Surface: string(authz.Web), SchemaVersion: domain.CurrentEventSchema,
	}
	if err := s.Append(e); err != nil {
		t.Fatalf("decision rejected under live lease: %v", err)
	}
	after, _ := s.Task("task-1")
	if after.State != before.State {
		t.Fatalf("state changed %s -> %s", before.State, after.State)
	}
	if after.Lease == nil || *after.Lease != *before.Lease {
		t.Fatalf("lease changed: %+v -> %+v", before.Lease, after.Lease)
	}
	if after.Description != before.Description || after.LifecyclePhase != before.LifecyclePhase {
		t.Fatalf("contract fields changed: %+v", after)
	}

	intent, err := s.EffectiveIntent("task-1")
	if err != nil {
		t.Fatal(err)
	}
	if len(intent.Decisions) != 1 || intent.Decisions[0].Value != "use b" {
		t.Fatalf("standing set = %+v", intent.Decisions)
	}
	if intent.Decisions[0].Source.ExternalID != "issue-1#c7" {
		t.Fatalf("provenance lost: %+v", intent.Decisions[0].Source)
	}

	// Same answer after a restart replay, from the log alone.
	reopened, err := Open(dir)
	if err != nil {
		t.Fatal(err)
	}
	replayed, err := reopened.EffectiveIntent("task-1")
	if err != nil {
		t.Fatal(err)
	}
	if len(replayed.Decisions) != 1 || replayed.Decisions[0].ID != "d1" {
		t.Fatalf("replayed standing set = %+v", replayed.Decisions)
	}
}

func TestEffectiveIntentUnknownTask(t *testing.T) {
	s, err := Open(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	if _, err := s.EffectiveIntent("nope"); !errors.Is(err, domain.ErrNotFound) {
		t.Fatalf("want ErrNotFound, got %v", err)
	}
}