package errors

import (
	"testing"

	"github.com/go-playground/validator/v10"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestFromValidatorError(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Email string `validate:"required,email"`
		Age   int    `validate:"min=18"`
	}

	s := TestStruct{Email: "invalid", Age: 15}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	require.NotNil(t, appErr)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Equal(t, "Validation failed", appErr.Message)
	assert.Greater(t, len(appErr.Details), 0)

	// Vérifier que les détails contiennent les erreurs attendues
	detailFields := make([]string, len(appErr.Details))
	for i, detail := range appErr.Details {
		detailFields[i] = detail.Field
	}

	assert.Contains(t, detailFields, "Email")
	assert.Contains(t, detailFields, "Age")
}

func TestFromValidatorError_Required(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Name string `validate:"required"`
	}

	s := TestStruct{Name: ""}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Len(t, appErr.Details, 1)
	assert.Equal(t, "Name", appErr.Details[0].Field)
	assert.Contains(t, appErr.Details[0].Message, "required")
}

func TestFromValidatorError_Email(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Email string `validate:"email"`
	}

	s := TestStruct{Email: "not-an-email"}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Len(t, appErr.Details, 1)
	assert.Equal(t, "Email", appErr.Details[0].Field)
	assert.Contains(t, appErr.Details[0].Message, "email")
}

func TestFromValidatorError_Min(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Age int `validate:"min=18"`
	}

	s := TestStruct{Age: 15}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Len(t, appErr.Details, 1)
	assert.Contains(t, appErr.Details[0].Message, "at least")
	assert.Contains(t, appErr.Details[0].Message, "18")
}

func TestFromValidatorError_Max(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Age int `validate:"max=100"`
	}

	s := TestStruct{Age: 150}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Len(t, appErr.Details, 1)
	assert.Contains(t, appErr.Details[0].Message, "at most")
	assert.Contains(t, appErr.Details[0].Message, "100")
}

func TestFromValidatorError_MultipleFields(t *testing.T) {
	validate := validator.New()

	type TestStruct struct {
		Email    string `validate:"required,email"`
		Username string `validate:"required,min=3"`
		Age      int    `validate:"min=18,max=100"`
	}

	s := TestStruct{
		Email:    "invalid-email",
		Username: "ab", // Trop court
		Age:      150,  // Trop grand
	}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.GreaterOrEqual(t, len(appErr.Details), 3)

	// Vérifier que tous les champs sont présents
	fields := make(map[string]bool)
	for _, detail := range appErr.Details {
		fields[detail.Field] = true
	}

	assert.True(t, fields["Email"])
	assert.True(t, fields["Username"])
	assert.True(t, fields["Age"])
}

func TestFromValidatorError_NonValidationError(t *testing.T) {
	// Tester avec une erreur qui n'est pas une ValidationErrors
	err := New(ErrCodeInternal, "Some other error")
	appErr := FromValidatorError(err)

	assert.Equal(t, ErrCodeValidation, appErr.Code)
	assert.Contains(t, appErr.Message, "Some other error")
	assert.Empty(t, appErr.Details)
}

func TestGetValidationMessage_Tags(t *testing.T) {
	validate := validator.New()

	tests := []struct {
		name      string
		structVal interface{}
		field     string
		tag       string
		contains  []string
	}{
		{
			name: "url tag",
			structVal: struct {
				URL string `validate:"url"`
			}{URL: "not-a-url"},
			field:    "URL",
			tag:      "url",
			contains: []string{"URL", "valid URL"},
		},
		{
			name: "len tag",
			structVal: struct {
				Code string `validate:"len=5"`
			}{Code: "123"},
			field:    "Code",
			tag:      "len",
			contains: []string{"Code", "exactly", "5"},
		},
		{
			name: "gte tag",
			structVal: struct {
				Value int `validate:"gte=10"`
			}{Value: 5},
			field:    "Value",
			tag:      "gte",
			contains: []string{"Value", "greater than or equal to"},
		},
		{
			name: "lte tag",
			structVal: struct {
				Value int `validate:"lte=100"`
			}{Value: 150},
			field:    "Value",
			tag:      "lte",
			contains: []string{"Value", "less than or equal to"},
		},
		{
			name: "oneof tag",
			structVal: struct {
				Status string `validate:"oneof=active inactive pending"`
			}{Status: "invalid"},
			field:    "Status",
			tag:      "oneof",
			contains: []string{"Status", "one of"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validate.Struct(tt.structVal)
			require.Error(t, err)

			appErr := FromValidatorError(err)
			require.NotNil(t, appErr)
			assert.Greater(t, len(appErr.Details), 0)

			// Trouver le détail correspondant au champ
			var foundDetail *ErrorDetail
			for i := range appErr.Details {
				if appErr.Details[i].Field == tt.field {
					foundDetail = &appErr.Details[i]
					break
				}
			}

			require.NotNil(t, foundDetail, "Detail for field %s not found", tt.field)
			for _, contains := range tt.contains {
				assert.Contains(t, foundDetail.Message, contains)
			}
		})
	}
}

func TestFromValidatorError_AdditionalTags(t *testing.T) {
	validate := validator.New()

	tests := []struct {
		name         string
		structVal    interface{}
		expectedTags []string
	}{
		{
			name: "gt tag",
			structVal: struct {
				Value int `validate:"gt=10"`
			}{Value: 5},
			expectedTags: []string{"gt"},
		},
		{
			name: "lt tag",
			structVal: struct {
				Value int `validate:"lt=100"`
			}{Value: 150},
			expectedTags: []string{"lt"},
		},
		{
			name: "alphanum tag",
			structVal: struct {
				Code string `validate:"alphanum"`
			}{Code: "test@123"},
			expectedTags: []string{"alphanum"},
		},
		{
			name: "alpha tag",
			structVal: struct {
				Name string `validate:"alpha"`
			}{Name: "test123"},
			expectedTags: []string{"alpha"},
		},
		{
			name: "numeric tag",
			structVal: struct {
				Number string `validate:"numeric"`
			}{Number: "abc123"},
			expectedTags: []string{"numeric"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validate.Struct(tt.structVal)
			require.Error(t, err)

			appErr := FromValidatorError(err)
			require.NotNil(t, appErr)
			assert.Equal(t, ErrCodeValidation, appErr.Code)
			assert.Greater(t, len(appErr.Details), 0)

			// Vérifier que le message contient le champ
			assert.NotEmpty(t, appErr.Details[0].Field)
			assert.NotEmpty(t, appErr.Details[0].Message)
		})
	}
}

func TestGetValidationMessage_DefaultCase(t *testing.T) {
	// Test que le default case de getValidationMessage fonctionne
	// On ne peut pas tester avec un tag réellement inconnu car le validateur panique
	// On teste plutôt que le code gère bien tous les cas avec des tags valides
	// Le default case sera testé indirectement via la couverture de code

	validate := validator.New()

	type TestStruct struct {
		CustomField string `validate:"required"`
	}

	// Test avec un tag valide pour s'assurer que le code fonctionne
	s := TestStruct{CustomField: ""}
	err := validate.Struct(s)
	require.Error(t, err)

	appErr := FromValidatorError(err)
	require.NotNil(t, appErr)

	// Vérifier que le message contient le champ
	assert.Greater(t, len(appErr.Details), 0)
	assert.Contains(t, appErr.Details[0].Message, "CustomField")

	// Note: Le default case de getValidationMessage est couvert par la couverture de code
	// mais ne peut pas être testé directement car go-playground/validator
	// panique lors de la création du validateur avec des tags inconnus
}