package adapter_test

import (
	"context"
	"testing"
	"time"

	"github.com/ThreeDotsLabs/watermill/message"
	"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 TestSubscriber_Subscribe_WithAllContextValues(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)
	defer sub.Close()

	ctx := context.WithValue(context.Background(), adapter.SubNameKey, "custom-sub")
	ctx = context.WithValue(ctx, adapter.IndexKey, 2)
	ctx = context.WithValue(ctx, adapter.ReceiverQueueSizeKey, 1500)

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

func TestSubscriber_Subscribe_ReuseExistingConsumer(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)
	defer sub.Close()

	ctx := context.Background()

	// Subscribe first time
	msgChan1, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan1)

	// Wait a bit
	time.Sleep(100 * time.Millisecond)

	// Subscribe again with same topic - should reuse consumer
	msgChan2, err := sub.Subscribe(ctx, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan2)
}

func TestSubscriber_Subscribe_DifferentIndices(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)
	defer sub.Close()

	ctx1 := context.WithValue(context.Background(), adapter.IndexKey, 0)
	msgChan1, err := sub.Subscribe(ctx1, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan1)

	ctx2 := context.WithValue(context.Background(), adapter.IndexKey, 1)
	msgChan2, err := sub.Subscribe(ctx2, "test-topic")
	require.NoError(t, err)
	assert.NotNil(t, msgChan2)
}

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

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

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

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

func TestSubscriber_Close_WithMultipleSubscriptions(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, "topic-1")
	require.NoError(t, err)

	_, err = sub.Subscribe(ctx, "topic-2")
	require.NoError(t, err)

	time.Sleep(100 * time.Millisecond)

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

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

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()

	pub, err := adapter.NewPublisherWithPulsarClient(mockClient, log)
	require.NoError(t, err)
	defer pub.Close()

	// Publish with no messages - should succeed
	err = pub.Publish("test-topic")
	require.NoError(t, err)
}

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

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()

	pub, err := adapter.NewPublisherWithPulsarClient(mockClient, log)
	require.NoError(t, err)
	defer pub.Close()

	msg1 := message.NewMessage("uuid-1", []byte("payload-1"))
	msg2 := message.NewMessage("uuid-2", []byte("payload-2"))
	msg3 := message.NewMessage("uuid-3", []byte("payload-3"))

	err = pub.Publish("test-topic", msg1, msg2, msg3)
	require.NoError(t, err)

	producer := mockClient.GetProducer("test-topic")
	require.NotNil(t, producer)
	messages := producer.GetMessages()
	require.Len(t, messages, 3)
}

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

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()

	pub, err := adapter.NewPublisherWithPulsarClient(mockClient, log)
	require.NoError(t, err)

	msg1 := message.NewMessage("uuid-1", []byte("payload-1"))
	msg2 := message.NewMessage("uuid-2", []byte("payload-2"))

	err = pub.Publish("topic-1", msg1)
	require.NoError(t, err)

	err = pub.Publish("topic-2", msg2)
	require.NoError(t, err)

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

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

	mockClient := mocks.NewMockPulsarClient()
	log := logger.NewNopLogger()

	pub, err := adapter.NewPublisherWithPulsarClient(mockClient, log)
	require.NoError(t, err)

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

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