package main

import (
	"bytes"
	"context"
	"io"
	"testing"

	commandkit "gitea.maximumdirect.net/eric/CommandKit"
	"gitea.maximumdirect.net/eric/CommandKit/integrations/ckconfig"
	configkit "gitea.maximumdirect.net/eric/ConfigKit"
	"go.yaml.in/yaml/v4"
)

func TestComposedApplicationDiffUsesFixturesAndCampaignOverride(t *testing.T) {
	app, err := newApp()
	if err != nil {
		t.Fatal(err)
	}
	args := []string{"config", "diff", "--scope", "app", "--config", "fixtures/before.yml", "--against-config", "fixtures/after.yml"}
	var output bytes.Buffer
	outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &output, Err: io.Discard})
	if outcome.Kind != commandkit.OutcomeSuccess {
		t.Fatalf("fixture diff outcome = %#v", outcome)
	}
	value := composedReportValue(t, output.Bytes(), "changes", "default_campaign")
	if value == nil || value.Value != "autumn" {
		t.Fatalf("fixture diff default_campaign = %#v; report %q", value, output.String())
	}

	output.Reset()
	args = append(args, "--campaign", "spring", "--limit=0")
	outcome = app.Execute(context.Background(), args, commandkit.Streams{Out: &output, Err: io.Discard})
	if outcome.Kind != commandkit.OutcomeSuccess {
		t.Fatalf("overridden fixture diff outcome = %#v", outcome)
	}
	for _, category := range []string{"additions", "changes", "deletions"} {
		if node := composedReportValue(t, output.Bytes(), category); len(node.Content) != 0 {
			t.Fatalf("campaign override left %s: %q", category, output.String())
		}
	}
}

func TestApplicationCacheSeparatesSelectionsCampaignValuesAndPresence(t *testing.T) {
	cache := &runCache{}
	beforeSelection := ckconfigSelection("fixtures/before.yml")
	afterSelection := ckconfigSelection("fixtures/after.yml")
	load := func(selection ckconfig.Selection, input *inspectionInput) *configkit.Result[appConfiguration] {
		t.Helper()
		result, err := loadApplicationConfig(context.Background(), selection, input, cache)
		if err != nil {
			t.Fatal(err)
		}
		return result
	}

	before := load(beforeSelection, nil)
	after := load(afterSelection, nil)
	if before.Config.DefaultCampaign != "spring" || after.Config.DefaultCampaign != "autumn" || before == after {
		t.Fatalf("file selections shared or returned wrong values: before=%#v after=%#v", before.Config, after.Config)
	}
	defaultAfter := load(afterSelection, nil)
	suppliedSpring := load(afterSelection, &inspectionInput{Campaign: commandkit.Supplied[string]{Value: "spring", Set: true}})
	suppliedAutumn := load(afterSelection, &inspectionInput{Campaign: commandkit.Supplied[string]{Value: "autumn", Set: true}})
	suppliedEmpty := load(afterSelection, &inspectionInput{Campaign: commandkit.Supplied[string]{Set: true}})
	if defaultAfter != after || suppliedSpring.Config.DefaultCampaign != "spring" || suppliedAutumn.Config.DefaultCampaign != "autumn" || suppliedEmpty.Config.DefaultCampaign != "" {
		t.Fatalf("campaign loading values = default:%q spring:%q autumn:%q empty:%q", defaultAfter.Config.DefaultCampaign, suppliedSpring.Config.DefaultCampaign, suppliedAutumn.Config.DefaultCampaign, suppliedEmpty.Config.DefaultCampaign)
	}
	if suppliedSpring == suppliedAutumn || suppliedAutumn == defaultAfter || suppliedEmpty == defaultAfter || len(cache.applications) != 5 {
		t.Fatalf("cache did not distinguish selection/input presence: entries=%d", len(cache.applications))
	}

	uncachedOne, err := loadApplicationConfig(context.Background(), afterSelection, nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	uncachedTwo, err := loadApplicationConfig(context.Background(), afterSelection, nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	if uncachedOne == uncachedTwo {
		t.Fatal("nil cache reused an application result")
	}
}

func TestApplicationCacheDoesNotRetainFailedLoads(t *testing.T) {
	cache := &runCache{}
	selection := ckconfig.Selection{Config: commandkit.Supplied[string]{Value: "fixtures/missing.yml", Set: true}}
	for range 2 {
		if _, err := loadApplicationConfig(context.Background(), selection, nil, cache); err == nil {
			t.Fatal("missing configuration unexpectedly loaded")
		}
	}
	if len(cache.applications) != 0 {
		t.Fatalf("failed result was cached: %#v", cache.applications)
	}
}

func TestComposedPromptKitAndDomainCommandsRemainAvailable(t *testing.T) {
	app, err := newApp()
	if err != nil {
		t.Fatal(err)
	}
	commands := [][]string{
		{"config", "validate", "--scope", "all", "--campaign", "spring", "--limit=0"},
		{"config", "show", "--scope", "promptkit", "--campaign", "spring"},
		{"config", "sources", "--scope", "promptkit", "--campaign", "spring"},
		{"config", "explain", "--scope", "promptkit", "--path", "/profiles/spring/model", "--campaign", "spring"},
		{"promptkit", "show", "prompt", "briefing", "--campaign", "spring", "--format", "yaml"},
		{"promptkit", "show", "profile", "spring", "--campaign", "spring"},
		{"session", "restore", "session-42", "--campaign", "spring"},
	}
	for _, args := range commands {
		outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: io.Discard, Err: io.Discard})
		if outcome.Kind != commandkit.OutcomeSuccess {
			t.Errorf("command %q outcome = %#v", args, outcome)
		}
	}
}

func TestPromptKitScopeDoesNotSupportConfigurationDiff(t *testing.T) {
	app, err := newApp()
	if err != nil {
		t.Fatal(err)
	}
	var output bytes.Buffer
	outcome := app.Execute(context.Background(), []string{"config", "diff", "--scope", "promptkit"}, commandkit.Streams{Out: &output, Err: io.Discard})
	if outcome.Kind != commandkit.OutcomeUsage || output.Len() != 0 {
		t.Fatalf("PromptKit diff outcome/output = %#v / %q", outcome, output.String())
	}
}

func composedReportValue(t *testing.T, data []byte, category string, fields ...string) *yaml.Node {
	t.Helper()
	var document yaml.Node
	if err := yaml.Unmarshal(data, &document); err != nil {
		t.Fatalf("decode composed report %q: %v", data, err)
	}
	node := composedField(document.Content[0], category)
	for _, field := range fields {
		node = composedField(node, field)
	}
	return node
}

func composedField(mapping *yaml.Node, name string) *yaml.Node {
	if mapping == nil || mapping.Kind != yaml.MappingNode {
		return nil
	}
	for index := 0; index+1 < len(mapping.Content); index += 2 {
		if mapping.Content[index].Value == name {
			return mapping.Content[index+1]
		}
	}
	return nil
}

func ckconfigSelection(path string) ckconfig.Selection {
	return ckconfig.Selection{Config: commandkit.Supplied[string]{Value: path, Set: true}}
}