package agentruntime

import (
	"context"
	"sync"
	"testing"
)

type conformanceProvider struct {
	mu    sync.Mutex
	specs []ExecutionSpec
}

func (p *conformanceProvider) Name() string { return "fixture" }

func (p *conformanceProvider) Capabilities(context.Context) (Capabilities, error) {
	return Capabilities{AdapterName: p.Name(), Targets: []string{"fixture"}, MaxConcurrency: 1}, nil
}

func (p *conformanceProvider) Execute(ctx context.Context, spec ExecutionSpec, sink EventSink) error {
	p.mu.Lock()
	p.specs = append(p.specs, spec)
	p.mu.Unlock()
	for _, event := range []RuntimeEvent{
		{RunID: spec.RunID, Type: EventTypeStart},
		{RunID: spec.RunID, Type: EventTypeDelta, Delta: spec.SessionID},
		{RunID: spec.RunID, Type: EventTypeComplete},
		{RunID: spec.RunID, Type: EventTypeComplete, Message: "duplicate"},
	} {
		if err := sink.Emit(ctx, event); err != nil {
			return err
		}
	}
	return nil
}

type nodeHostFixture struct{}
type standaloneHostFixture struct{}

func (nodeHostFixture) run(ctx context.Context, provider Provider, spec ExecutionSpec, sink EventSink) error {
	return provider.Execute(ctx, spec, NewTerminalEmitter(sink))
}

func (standaloneHostFixture) run(ctx context.Context, provider Provider, spec ExecutionSpec, sink EventSink) error {
	return provider.Execute(ctx, spec, NewTerminalEmitter(sink))
}

func TestProviderHostConformance(t *testing.T) {
	provider := &conformanceProvider{}
	tests := []struct {
		name string
		run  func(context.Context, Provider, ExecutionSpec, EventSink) error
		mode SessionMode
	}{
		{name: "node", run: nodeHostFixture{}.run, mode: SessionModeCreateIfMissing},
		{name: "standalone", run: standaloneHostFixture{}.run, mode: SessionModeRequireExisting},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			recorder := &eventRecorder{}
			spec := ExecutionSpec{
				RunID:       "run-" + test.name,
				Adapter:     provider.Name(),
				Target:      "fixture",
				SessionID:   "session-" + test.name,
				SessionMode: test.mode,
			}
			if err := test.run(context.Background(), provider, spec, recorder); err != nil {
				t.Fatalf("run() error = %v", err)
			}
			if len(recorder.events) != 3 || recorder.events[2].Type != EventTypeComplete {
				t.Fatalf("events = %#v", recorder.events)
			}
		})
	}

	provider.mu.Lock()
	defer provider.mu.Unlock()
	if len(provider.specs) != 2 {
		t.Fatalf("executed specs = %d, want 2", len(provider.specs))
	}
	if provider.specs[0].SessionMode != SessionModeCreateIfMissing ||
		provider.specs[1].SessionMode != SessionModeRequireExisting {
		t.Fatalf("session modes = %q, %q", provider.specs[0].SessionMode, provider.specs[1].SessionMode)
	}
}