package bootstrap

import (
	"context"
	"errors"
	"strings"
	"testing"
	"time"

	"proxy-pool/internal/config"
	"proxy-pool/internal/controller/admin"
	"proxy-pool/internal/controller/pool"
	"proxy-pool/internal/controller/provider"
	controllerRuntime "proxy-pool/internal/controller/runtime"
	"proxy-pool/internal/domain/activitypool"
	"proxy-pool/internal/domain/adminstate"
	extractionDomain "proxy-pool/internal/domain/extraction"
	"proxy-pool/internal/domain/upstream"
	"proxy-pool/internal/platform/admission"
	"proxy-pool/internal/platform/credentials"
)

var bootstrapTestFingerprintKey = []byte("0123456789abcdef0123456789abcdef")

func TestRunLoadsOneSnapshotCommitsItAndClosesInfrastructure(t *testing.T) {
	t.Parallel()
	resolver := &memoryResolver{files: map[string][]byte{"controller.yaml": []byte(bootstrapTestConfig)}}
	state := adminstate.NewMemoryStore()
	activity := &stubActivityStore{}
	credentialStore, err := credentials.NewMemoryStore(10)
	if err != nil {
		t.Fatalf("NewMemoryStore(): %v", err)
	}
	closeErr := errors.New("close failed")
	infrastructure := &stubInfrastructure{ports: ports{
		state: state, activity: activity, readiness: readyStub{}, metricsReadiness: readyStub{},
		admission:   admission.AllowAll{},
		coordinator: coordinatorStub{}, credentials: credentialStore,
		close: func() error { return closeErr },
	}}
	runErr := errors.New("runtime failed")
	factory := &recordingRuntimeFactory{runner: runnerStub{err: runErr}}
	now := time.Date(2026, 7, 30, 11, 0, 0, 0, time.UTC)

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	err = run(ctx, Options{
		ConfigPath: "controller.yaml", Resolver: resolver, Now: func() time.Time { return now },
		FingerprintKey: bootstrapTestFingerprintKey,
	}, infrastructure, factory)
	if !errors.Is(err, runErr) || !errors.Is(err, closeErr) {
		t.Fatalf("run() error = %v, want runtime and close errors", err)
	}
	if resolver.reads != 1 {
		t.Fatalf("configuration reads = %d, want 1", resolver.reads)
	}
	if infrastructure.opens != 1 || infrastructure.configuration == nil {
		t.Fatalf("infrastructure opens = %d, config = %p", infrastructure.opens, infrastructure.configuration)
	}
	snapshot, snapshotErr := state.Snapshot(context.Background())
	if snapshotErr != nil || snapshot.Config == nil || snapshot.Config.Source != "controller.yaml" || snapshot.Revision != 1 {
		t.Fatalf("management snapshot = %+v, %v", snapshot, snapshotErr)
	}
	if factory.configuration == nil || factory.dependencies.Extractor == nil ||
		factory.dependencies.Readiness == nil || factory.dependencies.AdminService == nil ||
		factory.dependencies.MetricsHandler == nil {
		t.Fatalf("runtime assembly = config:%p dependencies:%+v", factory.configuration, factory.dependencies)
	}
}

func TestRunRejectsInvalidOptionsBeforeIO(t *testing.T) {
	t.Parallel()
	valid := Options{ConfigPath: "controller.yaml", Resolver: &memoryResolver{}, Now: time.Now}
	tests := []struct {
		name    string
		ctx     context.Context
		options Options
	}{
		{name: "nil context", options: valid},
		{name: "missing path", ctx: context.Background(), options: Options{Resolver: valid.Resolver, Now: time.Now}},
		{name: "unclean path", ctx: context.Background(), options: Options{ConfigPath: " controller.yaml", Resolver: valid.Resolver, Now: time.Now}},
		{name: "missing resolver", ctx: context.Background(), options: Options{ConfigPath: "controller.yaml", Now: time.Now}},
	}
	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()
			if err := run(test.ctx, test.options, &stubInfrastructure{}, &recordingRuntimeFactory{}); !errors.Is(err, ErrInvalidOptions) {
				t.Fatalf("run() error = %v", err)
			}
		})
	}
}

func TestRunRejectsMissingAdminFingerprintKeyBeforeOpeningInfrastructure(t *testing.T) {
	for name, key := range map[string][]byte{
		"missing": nil,
		"short":   []byte("too-short"),
	} {
		t.Run(name, func(t *testing.T) {
			infrastructure := &stubInfrastructure{}
			err := run(context.Background(), Options{
				ConfigPath:     "controller.yaml",
				Resolver:       &memoryResolver{files: map[string][]byte{"controller.yaml": []byte(bootstrapTestConfig)}},
				Now:            time.Now,
				FingerprintKey: key,
			}, infrastructure, &recordingRuntimeFactory{})
			if !errors.Is(err, ErrInvalidOptions) || !errors.Is(err, config.ErrInvalidFingerprint) {
				t.Fatalf("run() error = %v", err)
			}
			if infrastructure.opens != 0 {
				t.Fatalf("infrastructure opens = %d, want 0", infrastructure.opens)
			}
		})
	}
}

func TestRunRejectsMissingDistributionAdmissionDependency(t *testing.T) {
	t.Parallel()
	credentialStore, err := credentials.NewMemoryStore(10)
	if err != nil {
		t.Fatalf("NewMemoryStore(): %v", err)
	}
	infrastructure := &stubInfrastructure{ports: ports{
		state: adminstate.NewMemoryStore(), activity: &stubActivityStore{},
		readiness: readyStub{}, metricsReadiness: readyStub{},
		coordinator: coordinatorStub{}, credentials: credentialStore,
		close: func() error { return nil },
	}}
	factory := &recordingRuntimeFactory{runner: runnerStub{err: errors.New("runtime should not start")}}
	err = run(context.Background(), Options{
		ConfigPath:     "controller.yaml",
		Resolver:       &memoryResolver{files: map[string][]byte{"controller.yaml": []byte(bootstrapTestConfig)}},
		Now:            time.Now,
		FingerprintKey: bootstrapTestFingerprintKey,
	}, infrastructure, factory)
	if !errors.Is(err, ErrStartup) || !errors.Is(err, ErrInvalidOptions) {
		t.Fatalf("run() error = %v, want ErrStartup and ErrInvalidOptions", err)
	}
	if factory.configuration != nil {
		t.Fatal("runtime factory called without admission dependency")
	}
}

func TestRunSupportsProviderOnlyConfigurationWithoutHTTPRuntime(t *testing.T) {
	source := strings.ReplaceAll(bootstrapTestConfig, "distribution:\n  enabled: true", "distribution:\n  enabled: false")
	source = strings.ReplaceAll(source, "admin:\n  enabled: true", "admin:\n  enabled: false")
	source = strings.ReplaceAll(source, "metrics:\n  enabled: true", "metrics:\n  enabled: false")
	credentialStore, err := credentials.NewMemoryStore(10)
	if err != nil {
		t.Fatalf("NewMemoryStore(): %v", err)
	}
	infrastructure := &stubInfrastructure{ports: ports{
		activity: &stubActivityStore{}, coordinator: coordinatorStub{}, credentials: credentialStore,
		close: func() error { return nil },
	}}
	factory := &recordingRuntimeFactory{}
	ctx, cancel := context.WithCancel(context.Background())
	time.AfterFunc(20*time.Millisecond, cancel)
	err = run(ctx, Options{
		ConfigPath: "controller.yaml",
		Resolver:   &memoryResolver{files: map[string][]byte{"controller.yaml": []byte(source)}},
		Now:        time.Now,
	}, infrastructure, factory)
	if !errors.Is(err, context.Canceled) {
		t.Fatalf("run(provider only) error = %v, want context cancellation", err)
	}
	if factory.configuration != nil {
		t.Fatal("HTTP runtime factory was called for Provider-only configuration")
	}
}

func TestRunAdminDisableStopsActiveProviderRuntime(t *testing.T) {
	state := adminstate.NewMemoryStore()
	credentialStore, err := credentials.NewMemoryStore(200)
	if err != nil {
		t.Fatalf("NewMemoryStore(): %v", err)
	}
	started := make(chan string, 2)
	stopped := make(chan string, 2)
	infrastructure := &stubInfrastructure{ports: ports{
		state: state, activity: &stubActivityStore{}, readiness: readyStub{}, metricsReadiness: readyStub{},
		admission: admission.AllowAll{},
		coordinator: coordinatorFunc(func(ctx context.Context, upstreamID string) error {
			started <- upstreamID
			<-ctx.Done()
			stopped <- upstreamID
			return ctx.Err()
		}),
		credentials: credentialStore,
		close:       func() error { return nil },
	}}
	wantErr := errors.New("test HTTP runtime stopped")
	factory := runtimeFactoryFunc(func(
		_ *config.Config,
		dependencies controllerRuntime.Dependencies,
		_ controllerRuntime.Options,
	) (controllerRunner, error) {
		return runnerFunc(func(ctx context.Context) error {
			for {
				select {
				case upstreamID := <-started:
					if upstreamID != "provider-a" {
						continue
					}
					if _, err := dependencies.AdminService.SetUpstreamEnabled(ctx, admin.SetUpstreamCommand{
						RequestID: "req-disable", ActorID: "admin:test", Name: "provider-a", Enabled: false,
					}); err != nil {
						return err
					}
					for {
						select {
						case stoppedID := <-stopped:
							if stoppedID == "provider-a" {
								return wantErr
							}
						case <-ctx.Done():
							return ctx.Err()
						}
					}
				case <-ctx.Done():
					return ctx.Err()
				}
			}
		}), nil
	})

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	err = run(ctx, Options{
		ConfigPath:     "controller.yaml",
		Resolver:       &memoryResolver{files: map[string][]byte{"controller.yaml": []byte(bootstrapTestConfig)}},
		Now:            time.Now,
		FingerprintKey: bootstrapTestFingerprintKey,
	}, infrastructure, factory)
	if !errors.Is(err, wantErr) {
		t.Fatalf("run() error = %v, want %v", err, wantErr)
	}
}

func TestRetainProviderStatsKeepsAllConfiguredProviders(t *testing.T) {
	configuration, err := config.Load(strings.NewReader(bootstrapTestConfig))
	if err != nil {
		t.Fatalf("config.Load(): %v", err)
	}
	disabled := configuration.Upstreams["provider-b"]
	disabled.Enabled = false
	configuration.Upstreams["provider-b"] = disabled
	stats, err := provider.NewStatsRecorder(2)
	if err != nil {
		t.Fatalf("provider.NewStatsRecorder(): %v", err)
	}
	stats.Record(provider.Result{UpstreamID: "removed", Class: upstream.FetchError})
	stats.Record(provider.Result{UpstreamID: "provider-b", Class: upstream.FetchError})

	retainProviderStats(configuration, stats)
	stats.Record(provider.Result{UpstreamID: "provider-a", Class: upstream.FetchError})
	got := stats.ReadProviderStats([]string{"removed", "provider-a", "provider-b"})
	if got[0].FetchErrorCount != 0 || got[1].FetchErrorCount != 1 || got[2].FetchErrorCount != 1 {
		t.Fatalf("Provider stats after retention = %+v", got)
	}
}

type memoryResolver struct {
	files map[string][]byte
	reads int
}

func (*memoryResolver) LookupEnv(string) (string, bool) { return "", false }

func (resolver *memoryResolver) ReadFile(path string) ([]byte, error) {
	resolver.reads++
	content, ok := resolver.files[path]
	if !ok {
		return nil, errors.New("file missing")
	}
	return append([]byte(nil), content...), nil
}

type stubInfrastructure struct {
	ports         ports
	err           error
	opens         int
	configuration *config.Config
}

func (infrastructure *stubInfrastructure) Open(
	_ context.Context,
	configuration *config.Config,
) (ports, error) {
	infrastructure.opens++
	infrastructure.configuration = configuration
	return infrastructure.ports, infrastructure.err
}

type recordingRuntimeFactory struct {
	configuration *config.Config
	dependencies  controllerRuntime.Dependencies
	runner        controllerRunner
	err           error
}

func (factory *recordingRuntimeFactory) New(
	configuration *config.Config,
	dependencies controllerRuntime.Dependencies,
	options controllerRuntime.Options,
) (controllerRunner, error) {
	factory.configuration = configuration
	factory.dependencies = dependencies
	return factory.runner, factory.err
}

type runnerStub struct{ err error }

func (runner runnerStub) Run(context.Context) error { return runner.err }

type runnerFunc func(context.Context) error

func (run runnerFunc) Run(ctx context.Context) error { return run(ctx) }

type runtimeFactoryFunc func(
	*config.Config,
	controllerRuntime.Dependencies,
	controllerRuntime.Options,
) (controllerRunner, error)

func (factory runtimeFactoryFunc) New(
	configuration *config.Config,
	dependencies controllerRuntime.Dependencies,
	options controllerRuntime.Options,
) (controllerRunner, error) {
	return factory(configuration, dependencies, options)
}

type readyStub struct{}

func (readyStub) Ready(context.Context) error { return nil }

type stubActivityStore struct{}

func (*stubActivityStore) Extract(_ context.Context, command extractionDomain.Command) (extractionDomain.Result, error) {
	return extractionDomain.Result{Requested: command.Requested}, nil
}

func (*stubActivityStore) ReadStateInventory(
	_ context.Context,
	upstreamIDs []string,
	_ time.Time,
) ([]activitypool.StateInventory, error) {
	result := make([]activitypool.StateInventory, len(upstreamIDs))
	for index, upstreamID := range upstreamIDs {
		result[index].UpstreamID = upstreamID
	}
	return result, nil
}

func (*stubActivityStore) UpsertFetched(
	_ context.Context,
	_ string,
	batch activitypool.FetchedBatch,
) (activitypool.UpsertResult, error) {
	return activitypool.UpsertResult{Accepted: len(batch.Proxies), Inserted: len(batch.Proxies)}, nil
}

func (*stubActivityStore) ReadInventory(
	context.Context,
	string,
	time.Duration,
) (pool.InventorySnapshot, error) {
	return pool.InventorySnapshot{Managed: 100, AvailableSlots: 1_000}, nil
}

type coordinatorStub struct{}

func (coordinatorStub) RunLeader(
	ctx context.Context,
	_ string,
	_ provider.CoordinationLimits,
	_ func(context.Context, provider.LeaderSession) error,
) error {
	<-ctx.Done()
	return ctx.Err()
}

type coordinatorFunc func(context.Context, string) error

func (run coordinatorFunc) RunLeader(
	ctx context.Context,
	upstreamID string,
	_ provider.CoordinationLimits,
	_ func(context.Context, provider.LeaderSession) error,
) error {
	return run(ctx, upstreamID)
}

const bootstrapTestConfig = `
version: 1
security:
  requireProtectionOnPublicListen: true
gateway:
  enabled: false
distribution:
  enabled: true
  listen: 127.0.0.1:0
  auth: {mode: none}
  extraction:
    fulfillment: partial
    maxCountPerRequest: 20
    minRemainingTTL: 5s
    maxHealthCheckAge: 15s
    reserveForGateway: 5
    idempotencyTTL: 5m
admin:
  enabled: true
  listen: 127.0.0.1:0
  auth: {mode: none}
metrics:
  enabled: true
  listen: 127.0.0.1:0
storage:
  postgresURL: postgres://fixture
  redisURL: redis://fixture
routing:
  - name: extract
    enabled: true
    purpose: extract
    upstreams: [provider-a, provider-b]
    strategy: {type: sequential, switchAfterEmptyFetch: 5, endBehavior: stayLast}
    onUnavailable: {action: reject}
upstreams:
  provider-a: &upstream
    enabled: true
    exposure: [extract]
    provider: {billingMode: fetch, protocols: [http]}
    api:
      url: https://provider.invalid/proxies
      method: GET
      template: '{{.}}'
      auth: {type: none}
    proxyAuth: {type: response}
    pool: {maxSize: 100}
    capacity: {maxConcurrencyPerProxy: 10}
    refill: {reconcileInterval: 1s, minimumAvailableSlots: 100, targetAvailableSlots: 200}
    lifecycle: {ttl: 2m, allocationSafetyMargin: 10s}
    fetch: {estimatedIPsPerCall: 10, requestInterval: 1s, timeout: 3s, maxAttempts: 3, maxInFlight: 1, maxTotal: 1000}
    check:
      interval: 30s
      jitter: 20
      maxInFlight: 100
      timeout: 2s
      maxAttempts: 2
      maxConsecutiveFailures: 3
      urls: [https://example.invalid/health]
  provider-b: *upstream
`