package artifacts

import "testing"

func TestArtifactCatalogRegisterBuiltInsAndLookup(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterBuiltIns(); err != nil {
		t.Fatalf("RegisterBuiltIns() error = %v", err)
	}

	entry, ok := catalog.Lookup(ArtifactTranscriptFull)
	if !ok {
		t.Fatalf("Lookup(%q) ok = false, want true", ArtifactTranscriptFull)
	}
	if !entry.Planned {
		t.Fatalf("entry.Planned = false, want true")
	}
	if entry.Executable {
		t.Fatalf("entry.Executable = true, want false")
	}
	if entry.CanonicalRelPath != "transcripts/normalized.json" {
		t.Fatalf("entry.CanonicalRelPath = %q, want transcripts/normalized.json", entry.CanonicalRelPath)
	}
}

func TestArtifactCatalogRegisterConfiguredArtifactsDefaultsToEnabled(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(map[string]ConfiguredArtifactDefinition{
		"player_handout": {Enabled: false, OutputPath: "artifacts/player_handout.md"},
		"session_recap":  {Enabled: true, OutputPath: "artifacts/session_recap.md"},
	}, nil); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() error = %v", err)
	}

	recapID, ok := catalog.SourceIDForConfiguredKey("session_recap")
	if !ok {
		t.Fatal("SourceIDForConfiguredKey(session_recap) ok = false, want true")
	}
	recap, ok := catalog.Lookup(recapID)
	if !ok {
		t.Fatalf("Lookup(%q) ok = false, want true", recapID)
	}
	if !recap.Executable {
		t.Fatalf("recap.Executable = false, want true")
	}

	handoutID, ok := catalog.SourceIDForConfiguredKey("player_handout")
	if !ok {
		t.Fatal("SourceIDForConfiguredKey(player_handout) ok = false, want true")
	}
	handout, ok := catalog.Lookup(handoutID)
	if !ok {
		t.Fatalf("Lookup(%q) ok = false, want true", handoutID)
	}
	if handout.Executable {
		t.Fatalf("handout.Executable = true, want false")
	}
}

func TestArtifactCatalogRegisterConfiguredArtifactsSelectedSetOverridesEnabled(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap":  {Enabled: true, OutputPath: "artifacts/session_recap.md"},
			"player_handout": {Enabled: false, OutputPath: "artifacts/player_handout.md"},
		},
		[]string{"player_handout"},
	); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() error = %v", err)
	}

	entries := catalog.ListConfigured()
	if len(entries) != 2 {
		t.Fatalf("ListConfigured() len = %d, want 2", len(entries))
	}
	if entries[0].ConfiguredKey != "player_handout" || entries[0].Executable != true {
		t.Fatalf("entries[0] = %+v, want player_handout executable", entries[0])
	}
	if entries[1].ConfiguredKey != "session_recap" || entries[1].Executable != false {
		t.Fatalf("entries[1] = %+v, want session_recap disabled by selection", entries[1])
	}
}

func TestArtifactCatalogRejectsSelectedUnknownArtifact(t *testing.T) {
	catalog := NewArtifactCatalog()
	err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: true, OutputPath: "artifacts/session_recap.md"},
		},
		[]string{"unknown"},
	)
	if err == nil {
		t.Fatal("RegisterConfiguredArtifacts() error = nil, want non-nil")
	}
}

func TestArtifactCatalogRejectsConfiguredSourceConflictAcrossRegistrations(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: true, OutputPath: "artifacts/session_recap.md"},
		},
		nil,
	); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() first call error = %v", err)
	}
	err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: true, OutputPath: "artifacts/session_recap.md"},
		},
		nil,
	)
	if err == nil {
		t.Fatal("RegisterConfiguredArtifacts() error = nil, want non-nil")
	}
}

func TestArtifactCatalogMarkAvailableGenerated(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: true, OutputPath: "artifacts/session_recap.md"},
		},
		nil,
	); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() error = %v", err)
	}

	sourceID, _ := catalog.SourceIDForConfiguredKey("session_recap")
	if err := catalog.MarkAvailableGenerated(sourceID, "/tmp/session_recap.md"); err != nil {
		t.Fatalf("MarkAvailableGenerated() error = %v", err)
	}
	entry, _ := catalog.Lookup(sourceID)
	if !entry.Available {
		t.Fatalf("entry.Available = false, want true")
	}
	if entry.Provenance != ArtifactProvenanceGeneratedCurrentAnalyzeRun {
		t.Fatalf("entry.Provenance = %q, want %q", entry.Provenance, ArtifactProvenanceGeneratedCurrentAnalyzeRun)
	}
}

func TestArtifactCatalogMarkAvailableFromDisk(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: false, OutputPath: "artifacts/session_recap.md"},
		},
		nil,
	); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() error = %v", err)
	}

	sourceID, _ := catalog.SourceIDForConfiguredKey("session_recap")
	if err := catalog.MarkAvailableFromDisk(sourceID, "/tmp/session_recap.md"); err != nil {
		t.Fatalf("MarkAvailableFromDisk() error = %v", err)
	}
	entry, _ := catalog.Lookup(sourceID)
	if !entry.Available {
		t.Fatalf("entry.Available = false, want true")
	}
	if entry.Provenance != ArtifactProvenanceDisabledFromDisk {
		t.Fatalf("entry.Provenance = %q, want %q", entry.Provenance, ArtifactProvenanceDisabledFromDisk)
	}
}

func TestArtifactCatalogLookupPlannedButUnavailable(t *testing.T) {
	catalog := NewArtifactCatalog()
	if err := catalog.RegisterConfiguredArtifacts(
		map[string]ConfiguredArtifactDefinition{
			"session_recap": {Enabled: true, OutputPath: "artifacts/session_recap.md"},
		},
		nil,
	); err != nil {
		t.Fatalf("RegisterConfiguredArtifacts() error = %v", err)
	}

	sourceID, _ := catalog.SourceIDForConfiguredKey("session_recap")
	entry, ok := catalog.Lookup(sourceID)
	if !ok {
		t.Fatalf("Lookup(%q) ok = false, want true", sourceID)
	}
	if !entry.Planned {
		t.Fatalf("entry.Planned = false, want true")
	}
	if entry.Available {
		t.Fatalf("entry.Available = true, want false")
	}
}