package mediator

import (
	"context"
	"errors"
	"testing"
)

// --- test request / response types ---

type testRequest struct {
	Message string
}

type testResponse struct {
	Result string
}

// --- stub handler ---

type stubHandler struct {
	response testResponse
	err      error
}

func (h *stubHandler) Handle(_ context.Context, _ testRequest) (testResponse, error) {
	return h.response, h.err
}

// --- tests ---

func TestRegisterAndSend_Success(t *testing.T) {
	m := NewMediator()
	Register[testRequest, testResponse](m, &stubHandler{
		response: testResponse{Result: "ok"},
	})

	resp, err := Send[testRequest, testResponse](m, context.Background(), testRequest{Message: "hello"})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resp.Result != "ok" {
		t.Errorf("expected result %q, got %q", "ok", resp.Result)
	}
}

func TestSend_UnregisteredType(t *testing.T) {
	m := NewMediator()

	_, err := Send[testRequest, testResponse](m, context.Background(), testRequest{Message: "hello"})
	if err == nil {
		t.Fatal("expected error for unregistered type, got nil")
	}
}

func TestSend_HandlerError(t *testing.T) {
	m := NewMediator()
	expectedErr := errors.New("something went wrong")
	Register[testRequest, testResponse](m, &stubHandler{
		err: expectedErr,
	})

	_, err := Send[testRequest, testResponse](m, context.Background(), testRequest{Message: "hello"})
	if err == nil {
		t.Fatal("expected error from handler, got nil")
	}
	if err.Error() != expectedErr.Error() {
		t.Errorf("expected error %q, got %q", expectedErr.Error(), err.Error())
	}
}