package hlog

import (
	"testing"

	"github.com/rs/zerolog"
)

func TestLogLevel(t *testing.T) {
	tests := []struct {
		name    string
		level   string
		want    Level
		wantErr bool
	}{
		{
			name:    "trace level",
			level:   "trace",
			want:    zerolog.TraceLevel,
			wantErr: false,
		},
		{
			name:    "debug level",
			level:   "debug",
			want:    zerolog.DebugLevel,
			wantErr: false,
		},
		{
			name:    "info level",
			level:   "info",
			want:    zerolog.InfoLevel,
			wantErr: false,
		},
		{
			name:    "warn level",
			level:   "warn",
			want:    zerolog.WarnLevel,
			wantErr: false,
		},
		{
			name:    "error level",
			level:   "error",
			want:    zerolog.ErrorLevel,
			wantErr: false,
		},
		{
			name:    "fatal level",
			level:   "fatal",
			want:    zerolog.FatalLevel,
			wantErr: false,
		},
		{
			name:    "panic level",
			level:   "panic",
			want:    zerolog.PanicLevel,
			wantErr: false,
		},
		{
			name:    "invalid level",
			level:   "invalid",
			want:    0,
			wantErr: true,
		},
		{
			name:    "empty string",
			level:   "",
			want:    0,
			wantErr: true,
		},
		{
			name:    "uppercase level (should fail - case sensitive)",
			level:   "INFO",
			want:    0,
			wantErr: true,
		},
		{
			name:    "mixed case level (should fail - case sensitive)",
			level:   "Info",
			want:    0,
			wantErr: true,
		},
		{
			name:    "numeric string",
			level:   "123",
			want:    0,
			wantErr: true,
		},
		{
			name:    "whitespace",
			level:   " ",
			want:    0,
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := LogLevel(tt.level)

			if tt.wantErr {
				if err == nil {
					t.Errorf("LogLevel() expected error but got nil")
				}
				return
			}

			if err != nil {
				t.Errorf("LogLevel() unexpected error = %v", err)
				return
			}

			if got != tt.want {
				t.Errorf("LogLevel() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestLogLevel_AllValidLevels(t *testing.T) {
	// Ensure all valid levels are tested
	validLevels := map[string]Level{
		"trace": zerolog.TraceLevel,
		"debug": zerolog.DebugLevel,
		"info":  zerolog.InfoLevel,
		"warn":  zerolog.WarnLevel,
		"error": zerolog.ErrorLevel,
		"fatal": zerolog.FatalLevel,
		"panic": zerolog.PanicLevel,
	}

	for levelStr, expectedLevel := range validLevels {
		t.Run("valid_"+levelStr, func(t *testing.T) {
			got, err := LogLevel(levelStr)
			if err != nil {
				t.Errorf("LogLevel(%s) unexpected error = %v", levelStr, err)
				return
			}
			if got != expectedLevel {
				t.Errorf("LogLevel(%s) = %v, want %v", levelStr, got, expectedLevel)
			}
		})
	}
}

func TestLogLevel_ErrorMessage(t *testing.T) {
	_, err := LogLevel("invalid")
	if err == nil {
		t.Fatal("LogLevel() expected error but got nil")
	}

	expectedMsg := "Invalid log level specified."
	if err.Error() != expectedMsg {
		t.Errorf("LogLevel() error message = %v, want %v", err.Error(), expectedMsg)
	}
}