package config

import (
	"os"
	"testing"

	"github.com/rs/zerolog"
	"github.com/stretchr/testify/assert"
)

func TestGetConfig(t *testing.T) {
	// Set up test environment variables
	envVars := map[string]string{
		EnvLogLevel:        "debug",
		EnvRootPath:        ".",
		EnvNumWorkers:      "5",
		EnvWorkerBatchSize: "100",
		EnvMaxResponseSize: "1048576",
		EnvResponseTimeout: "30",
	}

	for k, v := range envVars {
		os.Setenv(k, v)
		defer os.Unsetenv(k)
	}

	// Get configuration
	config := GetConfig()

	// Assert configuration values
	assert.Equal(t, zerolog.DebugLevel, config.LogLevel)
	assert.Equal(t, ".", config.RootPath)
	assert.Equal(t, 5, config.NumOfWorkers)
	assert.Equal(t, 100, config.WorkerBatchSize)
	assert.Equal(t, 1048576, config.MaxResponseSize)
	assert.Equal(t, 30, config.ResponseTimeout)
}

func TestParsePositiveInt(t *testing.T) {
	tests := []struct {
		name       string
		param      string
		input      string
		want       int
		wantErr    bool
		errType    interface{}
		errMessage string
	}{
		{
			name:    "valid positive",
			param:   "TEST_PARAM",
			input:   "42",
			want:    42,
			wantErr: false,
		},
		{
			name:       "zero",
			param:      "TEST_PARAM",
			input:      "0",
			wantErr:    true,
			errType:    &ValidationError{},
			errMessage: "invalid value '0' for TEST_PARAM: must be positive",
		},
		{
			name:       "negative",
			param:      "TEST_PARAM",
			input:      "-1",
			wantErr:    true,
			errType:    &ValidationError{},
			errMessage: "invalid value '-1' for TEST_PARAM: must be positive",
		},
		{
			name:       "invalid",
			param:      "TEST_PARAM",
			input:      "abc",
			wantErr:    true,
			errType:    &ValidationError{},
			errMessage: "invalid value 'abc' for TEST_PARAM: must be a valid integer",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := parsePositiveInt(tt.param, tt.input)
			if tt.wantErr {
				assert.Error(t, err)
				assert.IsType(t, tt.errType, err)
				if tt.errMessage != "" {
					assert.Equal(t, tt.errMessage, err.Error())
				}
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.want, got)
			}
		})
	}
}

func TestConfigValidation(t *testing.T) {
	tests := []struct {
		name       string
		envVars    map[string]string
		wantErr    bool
		errMessage string
	}{
		{
			name: "invalid log level",
			envVars: map[string]string{
				EnvLogLevel: "invalid",
			},
			wantErr:    true,
			errMessage: "invalid value 'invalid' for LOG_LEVEL: must be one of: debug, info, warn, error",
		},
		{
			name: "invalid worker count",
			envVars: map[string]string{
				EnvLogLevel:   "debug",
				EnvRootPath:   ".",
				EnvNumWorkers: "-1",
			},
			wantErr:    true,
			errMessage: "invalid value '-1' for NUM_OF_WORKERS: must be positive",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clear environment
			os.Clearenv()

			// Set required environment variables
			for k, v := range tt.envVars {
				os.Setenv(k, v)
			}

			// Defer cleanup
			defer os.Clearenv()

			if tt.wantErr {
				assert.PanicsWithError(t, tt.errMessage, func() {
					GetConfig()
				})
			}
		})
	}
}