package processors

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

	"gitea.maximumdirect.net/ejr/feedkit/event"
)

type testProcessor struct {
	name string
}

func (p testProcessor) Process(context.Context, event.Event) (*event.Event, error) {
	return nil, nil
}

func TestRegistryRegisterValidation(t *testing.T) {
	t.Run("empty driver panics", func(t *testing.T) {
		r := NewRegistry()
		assertPanics(t, func() {
			r.Register("   ", func() (Processor, error) { return testProcessor{name: "x"}, nil })
		})
	})

	t.Run("nil factory panics", func(t *testing.T) {
		r := NewRegistry()
		assertPanics(t, func() {
			r.Register("normalize", nil)
		})
	})

	t.Run("duplicate driver panics", func(t *testing.T) {
		r := NewRegistry()
		r.Register("normalize", func() (Processor, error) { return testProcessor{name: "a"}, nil })
		assertPanics(t, func() {
			r.Register("normalize", func() (Processor, error) { return testProcessor{name: "b"}, nil })
		})
	})
}

func TestRegistryBuildUnknownDriver(t *testing.T) {
	r := NewRegistry()
	_, err := r.Build("does_not_exist")
	if err == nil {
		t.Fatalf("expected error for unknown driver")
	}
	if !strings.Contains(err.Error(), "unknown processor driver") {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestRegistryBuildChainPreservesOrder(t *testing.T) {
	r := NewRegistry()
	r.Register("first", func() (Processor, error) { return testProcessor{name: "first"}, nil })
	r.Register("second", func() (Processor, error) { return testProcessor{name: "second"}, nil })

	chain, err := r.BuildChain([]string{"first", "second"})
	if err != nil {
		t.Fatalf("BuildChain error: %v", err)
	}
	if len(chain) != 2 {
		t.Fatalf("expected 2 processors, got %d", len(chain))
	}

	p0, ok := chain[0].(testProcessor)
	if !ok || p0.name != "first" {
		t.Fatalf("unexpected chain[0]: %#v", chain[0])
	}
	p1, ok := chain[1].(testProcessor)
	if !ok || p1.name != "second" {
		t.Fatalf("unexpected chain[1]: %#v", chain[1])
	}
}

func TestRegistryBuildChainIndexedFailure(t *testing.T) {
	r := NewRegistry()
	r.Register("ok", func() (Processor, error) { return testProcessor{name: "ok"}, nil })
	r.Register("broken", func() (Processor, error) { return nil, errors.New("boom") })

	_, err := r.BuildChain([]string{"ok", "broken"})
	if err == nil {
		t.Fatalf("expected error")
	}
	if !strings.Contains(err.Error(), "chain[1]") {
		t.Fatalf("expected indexed error, got: %v", err)
	}
}

func assertPanics(t *testing.T, fn func()) {
	t.Helper()
	defer func() {
		if recover() == nil {
			t.Fatalf("expected panic")
		}
	}()
	fn()
}