package domain

import (
	"errors"
	"testing"
)

func TestValidateKey(t *testing.T) {
	tests := []struct {
		name    string
		key     string
		wantErr error
	}{
		{name: "valid theme", key: "theme", wantErr: nil},
		{name: "valid language", key: "language", wantErr: nil},
		{name: "valid notifications_enabled", key: "notifications_enabled", wantErr: nil},
		{name: "unknown key", key: "unknown", wantErr: ErrUnknownKey},
		{name: "empty key", key: "", wantErr: ErrUnknownKey},
		{name: "similar key", key: "themes", wantErr: ErrUnknownKey},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateKey(tt.key)
			if tt.wantErr == nil {
				if err != nil {
					t.Errorf("expected no error, got %v", err)
				}
			} else {
				if !errors.Is(err, tt.wantErr) {
					t.Errorf("expected %v, got %v", tt.wantErr, err)
				}
			}
		})
	}
}

func TestValidateValue(t *testing.T) {
	tests := []struct {
		name    string
		key     string
		value   string
		wantErr error
	}{
		// Theme
		{name: "theme light", key: "theme", value: "light", wantErr: nil},
		{name: "theme dark", key: "theme", value: "dark", wantErr: nil},
		{name: "theme system", key: "theme", value: "system", wantErr: nil},
		{name: "theme invalid", key: "theme", value: "blue", wantErr: ErrInvalidValue},
		{name: "theme empty", key: "theme", value: "", wantErr: ErrInvalidValue},

		// Language
		{name: "language en", key: "language", value: "en", wantErr: nil},
		{name: "language fr", key: "language", value: "fr", wantErr: nil},
		{name: "language es", key: "language", value: "es", wantErr: nil},
		{name: "language invalid long", key: "language", value: "english", wantErr: ErrInvalidValue},
		{name: "language invalid uppercase", key: "language", value: "EN", wantErr: ErrInvalidValue},
		{name: "language invalid single char", key: "language", value: "e", wantErr: ErrInvalidValue},
		{name: "language empty", key: "language", value: "", wantErr: ErrInvalidValue},

		// Notifications
		{name: "notifications true", key: "notifications_enabled", value: "true", wantErr: nil},
		{name: "notifications false", key: "notifications_enabled", value: "false", wantErr: nil},
		{name: "notifications invalid yes", key: "notifications_enabled", value: "yes", wantErr: ErrInvalidValue},
		{name: "notifications invalid 1", key: "notifications_enabled", value: "1", wantErr: ErrInvalidValue},

		// Unknown key
		{name: "unknown key", key: "unknown", value: "anything", wantErr: ErrUnknownKey},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateValue(tt.key, tt.value)
			if tt.wantErr == nil {
				if err != nil {
					t.Errorf("expected no error, got %v", err)
				}
			} else {
				if !errors.Is(err, tt.wantErr) {
					t.Errorf("expected %v, got %v", tt.wantErr, err)
				}
			}
		})
	}
}

func TestPreference_Validate(t *testing.T) {
	tests := []struct {
		name    string
		pref    Preference
		wantErr error
	}{
		{
			name:    "valid preference",
			pref:    Preference{UserID: "user-1", Key: "theme", Value: "dark"},
			wantErr: nil,
		},
		{
			name:    "unknown key",
			pref:    Preference{UserID: "user-1", Key: "unknown", Value: "val"},
			wantErr: ErrUnknownKey,
		},
		{
			name:    "invalid value",
			pref:    Preference{UserID: "user-1", Key: "theme", Value: "blue"},
			wantErr: ErrInvalidValue,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := tt.pref.Validate()
			if tt.wantErr == nil {
				if err != nil {
					t.Errorf("expected no error, got %v", err)
				}
			} else {
				if !errors.Is(err, tt.wantErr) {
					t.Errorf("expected %v, got %v", tt.wantErr, err)
				}
			}
		})
	}
}