package router

import "testing"

// TestDecide_BackwardCompatible: a vanilla task (no new fields) must keep
// going through Claude Code. This is the contract that protects every
// existing inbox/*.md file.
func TestDecide_BackwardCompatible(t *testing.T) {
	d := Decide(Task{})
	if d.Provider != ProviderClaudeCode {
		t.Fatalf("default task must route to Claude Code, got %v (%s)", d.Provider, d.Reason)
	}
}

func TestDecide_NeedsClaudeCodeWinsOverEverything(t *testing.T) {
	d := Decide(Task{
		NeedsClaudeCode: true,
		AllowDelegation: true,
		PreferredAI:     "gpu",
	})
	if d.Provider != ProviderClaudeCode {
		t.Errorf("needs_claude_code must take precedence, got %v (%s)", d.Provider, d.Reason)
	}
}

func TestDecide_ExplicitClaudeCode(t *testing.T) {
	d := Decide(Task{PreferredAI: "claude-code", AllowDelegation: true})
	if d.Provider != ProviderClaudeCode {
		t.Errorf("explicit claude-code must route locally, got %v", d.Provider)
	}
}

func TestDecide_AllowDelegationFalseBlocksDelegation(t *testing.T) {
	d := Decide(Task{PreferredAI: "gpu", AllowDelegation: false})
	if d.Provider != ProviderClaudeCode {
		t.Errorf("allow_delegation=false must override preferred_ai, got %v (%s)",
			d.Provider, d.Reason)
	}
}

func TestDecide_DelegatedProviders(t *testing.T) {
	cases := []struct {
		pref string
		want Provider
	}{
		{"gpu", ProviderGPU},
		{"GPU", ProviderGPU},
		{"gemini", ProviderGemini},
		{"claude-api", ProviderClaudeAPI},
	}
	for _, c := range cases {
		d := Decide(Task{PreferredAI: c.pref, AllowDelegation: true})
		if d.Provider != c.want {
			t.Errorf("preferred_ai=%q want %v, got %v (%s)",
				c.pref, c.want, d.Provider, d.Reason)
		}
		if !d.Provider.IsDelegated() {
			t.Errorf("preferred_ai=%q should be delegated", c.pref)
		}
	}
}

func TestDecide_AutoMeansSecutoolsTriage(t *testing.T) {
	for _, pref := range []string{"auto", ""} {
		d := Decide(Task{PreferredAI: pref, AllowDelegation: true})
		if d.Provider != ProviderAuto {
			t.Errorf("preferred_ai=%q want ProviderAuto, got %v", pref, d.Provider)
		}
	}
}

func TestDecide_UnknownProviderFailsSafe(t *testing.T) {
	d := Decide(Task{PreferredAI: "claude-3-mystery", AllowDelegation: true})
	if d.Provider != ProviderClaudeCode {
		t.Errorf("unknown provider must fail-safe to Claude Code, got %v (%s)",
			d.Provider, d.Reason)
	}
}

func TestProvider_IsDelegated(t *testing.T) {
	cases := map[Provider]bool{
		ProviderClaudeCode: false,
		ProviderAuto:       true,
		ProviderGPU:        true,
		ProviderGemini:     true,
		ProviderClaudeAPI:  true,
	}
	for p, want := range cases {
		if got := p.IsDelegated(); got != want {
			t.Errorf("%v.IsDelegated() = %v, want %v", p, got, want)
		}
	}
}