package adapter_test

import (
	"testing"

	"github.com/ThreeDotsLabs/watermill/message"
	"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 TestNewPublisherWithPulsarClient(t *testing.T) {
	t.Parallel()

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

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

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

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

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

	msg := message.NewMessage("test-uuid", []byte("test payload"))
	err = pub.Publish("test-topic", msg)
	require.NoError(t, err)

	// Verify message was sent
	producer := mockClient.GetProducer("test-topic")
	require.NotNil(t, producer)
	messages := producer.GetMessages()
	require.Len(t, messages, 1)
	assert.Equal(t, "test-uuid", messages[0].Key)
	assert.Equal(t, []byte("test payload"), messages[0].Payload)
}

func TestPublisher_Publish_MultipleMessages(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("test-topic", msg1, msg2)
	require.NoError(t, err)

	producer := mockClient.GetProducer("test-topic")
	require.NotNil(t, producer)
	messages := producer.GetMessages()
	require.Len(t, messages, 2)
	assert.Equal(t, "uuid-1", messages[0].Key)
	assert.Equal(t, "uuid-2", messages[1].Key)
}

func TestPublisher_Publish_MultipleTopics(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)

	producer1 := mockClient.GetProducer("topic-1")
	require.NotNil(t, producer1)
	messages1 := producer1.GetMessages()
	require.Len(t, messages1, 1)

	producer2 := mockClient.GetProducer("topic-2")
	require.NotNil(t, producer2)
	messages2 := producer2.GetMessages()
	require.Len(t, messages2, 1)
}

func TestPublisher_Close(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)
}

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

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

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

	msg := message.NewMessage("test-uuid", []byte("test payload"))
	err = pub.Publish("test-topic", msg)
	require.NoError(t, err)

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

func TestPublisher_Publish_ReuseProducer(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"))
	err = pub.Publish("test-topic", msg1)
	require.NoError(t, err)

	msg2 := message.NewMessage("uuid-2", []byte("payload-2"))
	err = pub.Publish("test-topic", msg2)
	require.NoError(t, err)

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

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

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

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

	msg := message.NewMessage("uuid", []byte("payload"))
	err = pub.Publish("", msg)
	require.NoError(t, err)
}

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

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

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

	// Publish with nil message - should handle gracefully
	err = pub.Publish("test-topic", nil)
	// May succeed or fail depending on implementation
	_ = err

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

func TestPublisher_Publish_AfterClose(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)

	msg := message.NewMessage("uuid", []byte("payload"))
	err = pub.Publish("test-topic", msg)
	require.Error(t, err)
}

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

	config := adapter.PublisherConfig{
		URL: "invalid-url",
	}
	log := logger.NewNopLogger()

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