package usecase

import (
	"context"
	"errors"
	"reflect"
	"testing"

	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
)

type inspectionProfileRepository struct {
	profile *domain.ExecutionProfile
	err     error
	calls   int
	id      string
}

func (r *inspectionProfileRepository) GetProfile(_ context.Context, id string) (*domain.ExecutionProfile, error) {
	r.calls++
	r.id = id
	if r.err != nil {
		return nil, r.err
	}
	return r.profile, nil
}

func TestRunnerInspectProfileUsesExactSnapshotAndCopiesTarget(t *testing.T) {
	configured := domain.ExecutionTarget{
		BackendID: "backend", Endpoint: "https://backend.example/v1", Model: "model",
		Temperature: 0, APIKeyEnv: "OPTIONAL_KEY", ExtraParams: map[string]any{"nested": map[string]any{"value": "original"}},
	}
	profiles := &inspectionProfileRepository{profile: &domain.ExecutionProfile{
		ID: "  literal  ", ResolvedTarget: &configured,
		TargetPresence: domain.ExecutionTargetPresence{Temperature: true},
	}}
	runner := &Runner{profiles: profiles}
	first, err := runner.InspectProfile(context.Background(), "  literal  ")
	if err != nil {
		t.Fatalf("inspect exact ID: %v", err)
	}
	if profiles.calls != 1 || profiles.id != "  literal  " || first.ProfileID != profiles.id || !reflect.DeepEqual(first.EffectiveModelParams, configured) {
		t.Fatalf("inspection=%+v lookup=(%d,%q), want exact snapshot", first, profiles.calls, profiles.id)
	}
	first.EffectiveModelParams.ExtraParams["nested"].(map[string]any)["value"] = "changed"
	second, err := runner.InspectProfile(context.Background(), "  literal  ")
	if err != nil || second.EffectiveModelParams.ExtraParams["nested"].(map[string]any)["value"] != "original" {
		t.Fatalf("inspection mutated snapshot: (%+v, %v)", second, err)
	}
}

func TestRunnerInspectProfileDoesNotNeedExecutionCollaboratorsOrCredentials(t *testing.T) {
	t.Setenv("PROMPTKIT_INSPECTION_TEST_KEY", "")
	profiles := &inspectionProfileRepository{profile: &domain.ExecutionProfile{
		ID: "endpoint-only", ResolvedTarget: &domain.ExecutionTarget{
			Endpoint: "https://profile.example/v1", Model: "profile-model", APIKeyEnv: "PROMPTKIT_INSPECTION_TEST_KEY",
		},
	}}
	inspection, err := (&Runner{profiles: profiles}).InspectProfile(context.Background(), "endpoint-only")
	if err != nil || inspection.EffectiveModelParams.APIKeyEnv != "PROMPTKIT_INSPECTION_TEST_KEY" || inspection.APIKeyRequired {
		t.Fatalf("unexpected endpoint-only inspection: (%+v, %v)", inspection, err)
	}
}

func TestRunnerInspectProfileClassifiesLookupFailures(t *testing.T) {
	profiles := &inspectionProfileRepository{}
	runner := &Runner{profiles: profiles}
	if _, err := runner.InspectProfile(context.Background(), " \t "); !errors.Is(err, ErrInvalidRequest) || profiles.calls != 0 {
		t.Fatalf("blank inspection=(%v, calls=%d)", err, profiles.calls)
	}
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	if _, err := runner.InspectProfile(ctx, "profile"); !errors.Is(err, ErrProfileLoad) || !errors.Is(err, context.Canceled) || profiles.calls != 0 {
		t.Fatalf("canceled inspection=(%v, calls=%d)", err, profiles.calls)
	}
	profiles.err = profile.ErrProfileNotFound
	if _, err := runner.InspectProfile(context.Background(), "missing"); !errors.Is(err, ErrProfileLoad) || !errors.Is(err, profile.ErrProfileNotFound) {
		t.Fatalf("missing profile error=%v", err)
	}
	for _, invalid := range []*Runner{
		{},
		{profiles: &inspectionProfileRepository{}},
		{profiles: &inspectionProfileRepository{profile: &domain.ExecutionProfile{ID: "profile"}}},
	} {
		if _, err := invalid.InspectProfile(context.Background(), "profile"); !errors.Is(err, ErrProfileLoad) {
			t.Fatalf("invalid dependency error=%v", err)
		}
	}
}