package manifest

import (
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func TestLocalStoreCreateSaveLoadRoundTrip(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	m, err := store.Create(ctx, "2026-05-03")
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	now := time.Date(2026, 5, 3, 12, 0, 0, 0, time.UTC)
	m.MarkStageRunning("prepare", now)
	m.MarkStageSucceeded("prepare", now.Add(2*time.Second), []ArtifactRecord{{Kind: "transcript", LocalPath: "transcripts/base.json"}})
	m.Campaign = "forsaken"
	m.RunID = "20260515T031522Z-a1b2c3d4"
	m.LocalWorkDir = "/var/lib/narratio/work/forsaken/2026-05-03/20260515T031522Z-a1b2c3d4"
	m.LocalSpoolDir = "/var/spool/narratio/forsaken/2026-05-03/20260515T031522Z-a1b2c3d4/audio"
	m.S3Bucket = "my-dnd-archive"
	m.S3SessionPrefix = "dnd/campaigns/forsaken/sessions/2026-05-03/"
	m.S3RunPrefix = "dnd/campaigns/forsaken/sessions/2026-05-03/runs/20260515T031522Z-a1b2c3d4/"

	path := filepath.Join(t.TempDir(), "manifest.json")
	if err := store.Save(ctx, path, m); err != nil {
		t.Fatalf("Save() error = %v", err)
	}

	loaded, err := store.Load(ctx, path)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}

	if loaded.SessionID != "2026-05-03" {
		t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "2026-05-03")
	}
	if loaded.Campaign != "forsaken" {
		t.Fatalf("Campaign = %q, want %q", loaded.Campaign, "forsaken")
	}
	if loaded.RunID != "20260515T031522Z-a1b2c3d4" {
		t.Fatalf("RunID = %q, want run id", loaded.RunID)
	}
	stage, ok := loaded.Stages["prepare"]
	if !ok {
		t.Fatalf("stage prepare not found")
	}
	if stage.Status != StatusSucceeded {
		t.Fatalf("status = %q, want %q", stage.Status, StatusSucceeded)
	}
	if len(stage.Outputs) != 1 {
		t.Fatalf("outputs len = %d, want 1", len(stage.Outputs))
	}
	if loaded.UpdatedAt.IsZero() {
		t.Fatal("UpdatedAt is zero")
	}
}

func TestLocalStoreSaveUpdatesTimestamp(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	createdAt := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
	m := New("2026-05-03", createdAt)
	m.UpdatedAt = createdAt

	path := filepath.Join(t.TempDir(), "manifest.json")
	if err := store.Save(ctx, path, m); err != nil {
		t.Fatalf("first Save() error = %v", err)
	}
	firstUpdated := m.UpdatedAt

	time.Sleep(5 * time.Millisecond)
	if err := store.Save(ctx, path, m); err != nil {
		t.Fatalf("second Save() error = %v", err)
	}

	if !m.UpdatedAt.After(firstUpdated) {
		t.Fatalf("UpdatedAt = %v, want after %v", m.UpdatedAt, firstUpdated)
	}
}

func TestLocalStoreSaveAtomicPractical(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	dir := t.TempDir()
	path := filepath.Join(dir, "manifest.json")

	m := New("session-a", time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC))
	if err := store.Save(ctx, path, m); err != nil {
		t.Fatalf("Save() error = %v", err)
	}

	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("ReadFile() error = %v", err)
	}
	var decoded Manifest
	if err := json.Unmarshal(data, &decoded); err != nil {
		t.Fatalf("saved manifest is not valid JSON: %v", err)
	}

	entries, err := os.ReadDir(dir)
	if err != nil {
		t.Fatalf("ReadDir() error = %v", err)
	}
	for _, e := range entries {
		if strings.HasPrefix(e.Name(), ".manifest.json.tmp-") {
			t.Fatalf("found unexpected temp file after save: %s", e.Name())
		}
	}

	m.SessionID = "session-b"
	if err := store.Save(ctx, path, m); err != nil {
		t.Fatalf("second Save() error = %v", err)
	}

	loaded, err := store.Load(ctx, path)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if loaded.SessionID != "session-b" {
		t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "session-b")
	}
}

func TestLoadRejectsInvalidManifest(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	path := filepath.Join(t.TempDir(), "manifest.json")
	if err := os.WriteFile(path, []byte(`{"updated_at":"2026-05-03T10:00:00Z"}`), 0o644); err != nil {
		t.Fatalf("WriteFile() error = %v", err)
	}

	_, err := store.Load(ctx, path)
	if err == nil {
		t.Fatal("expected error, got nil")
	}
	if !strings.Contains(err.Error(), "session_id is required") {
		t.Fatalf("error = %q, want session_id validation", err.Error())
	}
}

func TestLocalStoreCreateSaveLoadRunManifestRoundTrip(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	run, err := store.CreateRun(
		ctx,
		"2026-05-03",
		"forsaken",
		"20260517T000000Z-abcdef12",
		true,
		[]string{"prepare", "transcribe"},
	)
	if err != nil {
		t.Fatalf("CreateRun() error = %v", err)
	}
	run.SessionManifestPath = "/var/lib/narratio/work/forsaken/2026-05-03/manifest.json"
	run.MarkStageRunning("prepare", time.Date(2026, 5, 3, 12, 1, 0, 0, time.UTC))
	run.MarkStageSucceeded("prepare", time.Date(2026, 5, 3, 12, 2, 0, 0, time.UTC), []ArtifactRecord{
		{Kind: "input", LocalPath: "inputs/session.yml"},
	})
	run.MarkSucceeded(time.Date(2026, 5, 3, 12, 3, 0, 0, time.UTC))

	path := filepath.Join(t.TempDir(), "run-manifest.json")
	if err := store.SaveRun(ctx, path, run); err != nil {
		t.Fatalf("SaveRun() error = %v", err)
	}

	loaded, err := store.LoadRun(ctx, path)
	if err != nil {
		t.Fatalf("LoadRun() error = %v", err)
	}

	if loaded.SessionID != "2026-05-03" {
		t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "2026-05-03")
	}
	if loaded.Campaign != "forsaken" {
		t.Fatalf("Campaign = %q, want %q", loaded.Campaign, "forsaken")
	}
	if loaded.RunID != "20260517T000000Z-abcdef12" {
		t.Fatalf("RunID = %q, want %q", loaded.RunID, "20260517T000000Z-abcdef12")
	}
	if loaded.Status != RunManifestStatusSucceeded {
		t.Fatalf("Status = %q, want %q", loaded.Status, RunManifestStatusSucceeded)
	}
	if loaded.Stages["prepare"] == nil || loaded.Stages["prepare"].Status != StatusSucceeded {
		t.Fatalf("prepare stage = %#v, want succeeded", loaded.Stages["prepare"])
	}
	if loaded.Stages["prepare"].Action != RunStageActionRun {
		t.Fatalf("prepare action = %q, want %q", loaded.Stages["prepare"].Action, RunStageActionRun)
	}
}

func TestLoadRunRejectsInvalidManifest(t *testing.T) {
	store := &LocalStore{}
	ctx := context.Background()

	path := filepath.Join(t.TempDir(), "run-manifest.json")
	if err := os.WriteFile(path, []byte(`{"session_id":"2026-05-03"}`), 0o644); err != nil {
		t.Fatalf("WriteFile() error = %v", err)
	}

	_, err := store.LoadRun(ctx, path)
	if err == nil {
		t.Fatal("expected error, got nil")
	}
	if !strings.Contains(err.Error(), "run_id is required") {
		t.Fatalf("error = %q, want run_id validation", err.Error())
	}
}