package logger_test

import (
	"errors"
	"testing"

	"github.com/stretchr/testify/assert"

	apilogger "go.yandata.net/iod/iod/trustlog-sdk/api/logger"
	"go.yandata.net/iod/iod/trustlog-sdk/internal/logger"
)

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)
	assert.NotNil(t, adapter)
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	err := errors.New("test error")
	fields := map[string]interface{}{
		"key1": "value1",
		"key2": 42,
	}

	assert.NotPanics(t, func() {
		adapter.Error("error message", err, fields)
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	fields := map[string]interface{}{
		"key1": "value1",
		"key2": 42,
	}

	assert.NotPanics(t, func() {
		adapter.Info("info message", fields)
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	fields := map[string]interface{}{
		"key1": "value1",
	}

	assert.NotPanics(t, func() {
		adapter.Debug("debug message", fields)
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	fields := map[string]interface{}{
		"key1": "value1",
	}

	assert.NotPanics(t, func() {
		adapter.Trace("trace message", fields)
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	fields1 := map[string]interface{}{
		"key1": "value1",
	}
	fields2 := map[string]interface{}{
		"key2": "value2",
	}

	newAdapter := adapter.With(fields1)
	assert.NotNil(t, newAdapter)

	// Test that fields are merged
	newAdapter2 := newAdapter.With(fields2)
	assert.NotNil(t, newAdapter2)

	assert.NotPanics(t, func() {
		newAdapter2.Info("test", map[string]interface{}{})
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)
	assert.NotNil(t, adapter)
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Debug("debug message")
		adapter.Debug("debug", "message", "with", "args")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Info("info message")
		adapter.Info("info", "message", "with", "args")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Warn("warn message")
		adapter.Warn("warn", "message", "with", "args")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	tests := []struct {
		name string
		test func()
	}{
		{
			name: "without error",
			test: func() {
				adapter.Error("error message")
			},
		},
		{
			name: "with error",
			test: func() {
				adapterWithErr := adapter.WithError(errors.New("test error"))
				adapterWithErr.Error("error message")
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.NotPanics(t, tt.test)
		})
	}
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Debugf("debug %s", "message")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Infof("info %s", "message")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Warnf("warn %s", "message")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	tests := []struct {
		name string
		test func()
	}{
		{
			name: "without error",
			test: func() {
				adapter.Errorf("error %s", "message")
			},
		},
		{
			name: "with error",
			test: func() {
				adapterWithErr := adapter.WithError(errors.New("test error"))
				adapterWithErr.Errorf("error %s", "message")
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.NotPanics(t, tt.test)
		})
	}
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	fields := map[string]interface{}{
		"key1": "value1",
	}

	subLogger := adapter.SubLogger(fields)
	assert.NotNil(t, subLogger)

	assert.NotPanics(t, func() {
		subLogger.Info("test")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	fields := map[string]interface{}{
		"key1": "value1",
		"key2": 42,
	}

	entry := adapter.WithFields(fields)
	assert.NotNil(t, entry)

	assert.NotPanics(t, func() {
		entry.Info("test")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	entry := adapter.WithField("key", "value")
	assert.NotNil(t, entry)

	assert.NotPanics(t, func() {
		entry.Info("test")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	err := errors.New("test error")
	entry := adapter.WithError(err)
	assert.NotNil(t, entry)

	assert.NotPanics(t, func() {
		entry.Error("test error message")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	entry1 := adapter.WithField("key1", "value1")
	entry2 := entry1.WithField("key2", "value2")

	assert.NotPanics(t, func() {
		entry2.Info("chained fields test")
	})

	// Test WithError separately
	entryWithErr := adapter.WithError(errors.New("test error"))
	assert.NotPanics(t, func() {
		entryWithErr.Error("chained fields test")
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewPulsarLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Debugf("debug %d", 1)
		adapter.Infof("info %d", 2)
		adapter.Warnf("warn %d", 3)
		adapter.Errorf("error %d", 4)
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	assert.NotPanics(t, func() {
		adapter.Error("error", errors.New("test"), map[string]interface{}{})
		adapter.Info("info", map[string]interface{}{})
		adapter.Debug("debug", map[string]interface{}{})
		adapter.Trace("trace", map[string]interface{}{})
	})
}

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

	l := apilogger.NewNopLogger()
	adapter := logger.NewWatermillLoggerAdapter(l)

	baseFields := map[string]interface{}{
		"base": "value",
	}
	extraFields := map[string]interface{}{
		"extra": "value",
	}

	adapterWithBase := adapter.With(baseFields)
	adapterWithBoth := adapterWithBase.With(extraFields)

	assert.NotPanics(t, func() {
		adapterWithBoth.Info("test", map[string]interface{}{})
	})
}