package adapter_test

import (
	"context"
	"testing"
	"time"

	"github.com/apache/pulsar-client-go/pulsar"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.yandata.net/iod/iod/trustlog-sdk/api/adapter"
	"go.yandata.net/iod/iod/trustlog-sdk/api/adapter/mocks"
	"go.yandata.net/iod/iod/trustlog-sdk/api/logger"
)

func TestNewSubscriberWithPulsarClient(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)
	assert.NotNil(t, sub)
}

func TestSubscriber_Subscribe(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()
	msgChan, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan)
}

func TestSubscriber_Subscribe_WithContextValues(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()

	msgChan, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan)
}

func TestSubscriber_Close(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	err = sub.Close()
	require.NoError(t, err)
}

func TestSubscriber_Close_AfterSubscribe(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()
	_, err = sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)

	err = sub.Close()
	require.NoError(t, err)
}

func TestSubscriber_Subscribe_MultipleTopics(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()
	msgChan1, err := sub.Subscribe(ctx, "topic-1")
	require.NoError(t, err)
	assert.NotNil(t, msgChan1)

	msgChan2, err := sub.Subscribe(ctx, "topic-2")
	require.NoError(t, err)
	assert.NotNil(t, msgChan2)
}

func TestSubscriber_Subscribe_ReuseConsumer(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()
	msgChan1, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)

	msgChan2, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)

	assert.NotNil(t, msgChan1)
	assert.NotNil(t, msgChan2)
}

func TestSubscriber_Subscribe_ContextCancellation(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx, cancel := context.WithCancel(context.Background())
	_, err = sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)

	// Cancel context
	cancel()

	// Wait a bit for goroutine to process cancellation
	time.Sleep(100 * time.Millisecond)

	// Close subscriber
	err = sub.Close()
	require.NoError(t, err)
}

func TestSubscriber_Subscribe_EmptyTopic(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	ctx := context.Background()
	msgChan, err := sub.Subscribe(ctx, "")
	require.NoError(t, err)
	assert.NotNil(t, msgChan)
}

func TestSubscriber_Close_MultipleTimes(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	err = sub.Close()
	require.NoError(t, err)

	// Close again should be safe
	err = sub.Close()
	require.NoError(t, err)
}

func TestSubscriber_Subscribe_AfterClose(t *testing.T) {
	t.Parallel()

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()
	config := adapter.SubscriberConfig{
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}

	sub, err := adapter.NewSubscriberWithPulsarClient(mockClient, config, log)
	require.NoError(t, err)

	err = sub.Close()
	require.NoError(t, err)

	ctx := context.Background()
	_, err = sub.Subscribe(ctx, "test-topic")
	// Behavior depends on implementation - may succeed or fail
	_ = err
}

func TestNewSubscriber_InvalidURL(t *testing.T) {
	t.Parallel()

	config := adapter.SubscriberConfig{
		URL:            "invalid-url",
		SubscriberName: "test-sub",
		SubscriberType: pulsar.Shared,
	}
	log := logger.NewNopLogger()

	_, err := adapter.NewSubscriber(config, log)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "cannot connect")
}