package channel

import (
	"context"
	"testing"

	"github.com/gochat/gochat/internal/model"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// mockProvider implements ChannelProvider for testing
type mockProvider struct {
	channelType ChannelType
}

func (m *mockProvider) Type() ChannelType                                         { return m.channelType }
func (m *mockProvider) Name() string                                              { return string(m.channelType) }
func (m *mockProvider) Description() string                                       { return "Mock " + string(m.channelType) }
func (m *mockProvider) ConfigSchema() *ConfigSchemaDefinition                     { return nil }
func (m *mockProvider) ValidateConfig(ctx context.Context, c ChannelConfig) error { return nil }
func (m *mockProvider) DefaultConfig() ChannelConfig                              { return ChannelConfig{} }
func (m *mockProvider) OnCreate(ctx context.Context, inbox *model.Inbox, c ChannelConfig) (ChannelConfig, error) {
	return c, nil
}
func (m *mockProvider) OnDestroy(ctx context.Context, inbox *model.Inbox, c ChannelConfig) error {
	return nil
}
func (m *mockProvider) ProcessIncoming(ctx context.Context, inbox *model.Inbox, raw []byte) (*IncomingMessage, error) {
	return &IncomingMessage{InboxID: inbox.ID}, nil
}
func (m *mockProvider) ValidateWebhookRequest(ctx context.Context, inbox *model.Inbox, req *WebhookRequest) error {
	return nil
}
func (m *mockProvider) SendMessage(ctx context.Context, inbox *model.Inbox, msg *model.Message, contact *model.Contact) (*SendResult, error) {
	return &SendResult{}, nil
}
func (m *mockProvider) GetContactProfile(ctx context.Context, inbox *model.Inbox, src string) (*ContactProfile, error) {
	return &ContactProfile{}, nil
}
func (m *mockProvider) Capabilities() ChannelCapabilities { return ChannelCapabilities{} }

func TestRegistry_RegisterAndGet(t *testing.T) {
	ct := ChannelType("test_mock_unique2")
	provider := &mockProvider{channelType: ct}

	err := Register(provider)
	require.NoError(t, err)

	got, err := Get(ct)
	require.NoError(t, err)
	assert.Equal(t, ct, got.Type())
}

func TestRegistry_Get_NotRegistered(t *testing.T) {
	_, err := Get(ChannelType("nonexistent_type_xyz"))
	require.Error(t, err)
}

func TestRegistry_Register_Duplicate(t *testing.T) {
	ct := ChannelType("test_dup2")
	provider := &mockProvider{channelType: ct}

	err := Register(provider)
	require.NoError(t, err)

	err = Register(provider)
	require.Error(t, err)
}

func TestRegistry_IsRegistered(t *testing.T) {
	ct := ChannelType("test_isregistered2")
	provider := &mockProvider{channelType: ct}

	assert.False(t, IsRegistered(ct))
	_ = Register(provider)
	assert.True(t, IsRegistered(ct))
}

func TestRegistry_List(t *testing.T) {
	types := List()
	assert.NotEmpty(t, types)
}

func TestRegistry_ListProviders(t *testing.T) {
	providers := ListProviders()
	assert.NotEmpty(t, providers)
}

func TestRegistry_GetRegistry(t *testing.T) {
	r := GetRegistry()
	assert.NotNil(t, r)
}

func TestRegistry_ProcessIncomingMessage_NotFound(t *testing.T) {
	_, err := ProcessIncomingMessage(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, []byte("{}"))
	require.Error(t, err)
}

func TestRegistry_SendMessageToChannel_NotFound(t *testing.T) {
	_, err := SendMessageToChannel(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, &model.Message{}, &model.Contact{})
	require.Error(t, err)
}

func TestRegistry_ValidateWebhookRequest_NotFound(t *testing.T) {
	err := ValidateWebhookRequest(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, &WebhookRequest{})
	require.Error(t, err)
}

func TestRegistry_InstanceMethods(t *testing.T) {
	r := &ChannelRegistry{providers: make(map[ChannelType]ChannelProvider)}
	ct := ChannelType("instance_test2")
	provider := &mockProvider{channelType: ct}

	err := r.RegisterOnInstance(provider)
	require.NoError(t, err)

	got, err := r.Get(ct)
	require.NoError(t, err)
	assert.Equal(t, ct, got.Type())
}