package models

import (
	"encoding/json"
	"errors"
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestValidationIssue_JSON(t *testing.T) {
	tests := []struct {
		name         string
		issue        ValidationIssue
		expectedJSON string
	}{
		{
			name:         "empty",
			issue:        ValidationIssue{},
			expectedJSON: `{"message":"", "severity":"critical"}`,
		},
		{
			name: "bare",
			issue: ValidationIssue{
				message: "error message",
			},
			expectedJSON: `{"message":"error message", "severity":"critical"}`,
		},
		{
			name: "generic",
			issue: ValidationIssue{
				message:   "error message",
				field:     NewFieldSelectorGroup(NewFieldSelector("field_name")),
				code:      "invalid_param",
				component: "openmeter",
				severity:  ErrorSeverityCritical,
			},
			expectedJSON: `{
				"code":"invalid_param",
				"component":"openmeter",
				"message":"error message",
				"field":"$.field_name",
				"severity":"critical"
			}`,
		},
		{
			name: "with attributes",
			issue: ValidationIssue{
				message: "error message",
				field: NewFieldSelectorGroup(NewFieldSelector("field_name").WithExpression(
					NewFieldAttrValue("key", "value"),
				)),
				code:      "invalid_param",
				component: "openmeter",
				severity:  ErrorSeverityWarning,
				attributes: Attributes{
					"attr1": "value1",
				},
			},
			expectedJSON: `{
				"code":"invalid_param",
				"component":"openmeter",
				"message":"error message",
				"field":"$.field_name[?(@.key=='value')]",
				"severity":"warning",
				"attr1": "value1"
			}`,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			b, err := json.Marshal(test.issue)
			require.NoErrorf(t, err, "marshaling ValidationIssue to JSON must not fail")

			assert.JSONEqf(t, test.expectedJSON, string(b), "JSON representation must match")
		})
	}
}

var errTestValidationIssue = ValidationIssue{
	code:     "test_validation_issue",
	message:  "test validation issue",
	field:    NewFieldSelectorGroup(NewFieldSelector("field")),
	severity: ErrorSeverityCritical,
}

func TestValidationIssue_WithAttrs(t *testing.T) {
	tests := []struct {
		name  string
		issue ValidationIssue
		attrs Attributes
	}{
		{
			name:  "empty",
			issue: errTestValidationIssue,
			attrs: nil,
		},
		{
			name:  "with attributes",
			issue: errTestValidationIssue,
			attrs: Attributes{
				"key1": "value1",
				"key2": "value2",
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			actual := test.issue.WithAttrs(test.attrs)

			assert.Emptyf(t, errTestValidationIssue.Attributes(), "original attributes must be empty")
			assert.Equalf(t, test.attrs, actual.Attributes(), "attributes must match")
		})
	}
}

func TestValidationIssue_WithField(t *testing.T) {
	t.Run("Should UNSET field if nil is passed", func(t *testing.T) {
		issue := errTestValidationIssue.Clone()

		withField := issue.WithField()

		assert.Equal(t, "", withField.Field().String(), "field must match")
		assert.Equal(t, "", withField.Field().JSONPath(), "field path must match")
	})

	t.Run("Should override field if non-nil path is passed", func(t *testing.T) {
		issue := errTestValidationIssue.Clone()

		desc := NewFieldSelectorGroup(NewFieldSelector("field_name"))

		withField := issue.WithField(desc)

		assert.Equal(t, desc.String(), withField.Field().String(), "field must match")
		assert.Equal(t, "$.field_name", withField.Field().JSONPath(), "field path must match")
	})
}

func TestValidationIssue_Clone(t *testing.T) {
	tests := []struct {
		name          string
		issue         ValidationIssue
		expectedIssue ValidationIssue
	}{
		{
			name:  "clone",
			issue: errTestValidationIssue,
			expectedIssue: ValidationIssue{
				attributes: errTestValidationIssue.attributes,
				code:       errTestValidationIssue.code,
				component:  errTestValidationIssue.component,
				message:    errTestValidationIssue.message,
				field:      errTestValidationIssue.field,
				severity:   errTestValidationIssue.severity,
				wraps:      errTestValidationIssue,
			},
		},
		{
			name:          "empty",
			issue:         ValidationIssue{},
			expectedIssue: ValidationIssue{wraps: ValidationIssue{}},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			actual := test.issue.Clone()

			assert.Equalf(t, test.expectedIssue, actual, "must match after clone")
		})
	}
}

func TestValidationIssue_UnwrapAndErrorsIs(t *testing.T) {
	base := errTestValidationIssue
	withField := base.WithField(NewFieldSelectorGroup(NewFieldSelector("field_name")))
	withAttrs := withField.WithAttr("key", "value")

	require.ErrorIs(t, withField, base)
	require.ErrorIs(t, withAttrs, withField)
	require.ErrorIs(t, withAttrs, base)

	assert.Equal(t, base.Error(), withField.Error())
	assert.Equal(t, withField.Error(), withAttrs.Error())
}

func TestValidationIssue_ErrorsIsWithJoin(t *testing.T) {
	base := NewValidationError("joined_code", "joined message")
	derived := base.WithPathString("field_name")
	joined := errors.Join(errors.New("other error"), derived)

	require.ErrorIs(t, joined, derived)
	require.ErrorIs(t, joined, base)
}

func TestAsValidationIssues(t *testing.T) {
	tests := []struct {
		name           string
		err            error
		expectError    bool
		expectedIssues ValidationIssues
	}{
		{
			name:           "nil",
			err:            nil,
			expectError:    false,
			expectedIssues: nil,
		},
		{
			name:           "error",
			err:            errors.New("error"),
			expectError:    true,
			expectedIssues: nil,
		},
		{
			name:           "error/wrapped",
			err:            fmt.Errorf("test: %w", errors.New("error")),
			expectError:    true,
			expectedIssues: nil,
		},
		{
			name: "mixed",
			err: fmt.Errorf("test: %w",
				errors.Join(
					errors.New("error 1"),
					NewValidationError("errcode1", "error message 1"),
					NewValidationWarning("errcode2", "error message 2"),
				),
			),
			expectError:    true,
			expectedIssues: nil,
		},
		{
			name: "mixed",
			err: fmt.Errorf("test: %w",
				errors.Join(
					errors.New("error 1"),
					NewValidationError("errcode1", "error message 1"),
					NewValidationWarning("errcode2", "error message 2"),
				),
			),
			expectError:    true,
			expectedIssues: nil,
		},
		{
			name: "unknown wrapped",
			err: fmt.Errorf("test: %w",
				errors.Join(
					ErrorWithComponent("component1",
						errors.New("error 1"),
					),
					NewValidationError("errcode1", "error message 1"),
					NewValidationWarning("errcode2", "error message 2"),
				),
			),
			expectError: false,
			expectedIssues: ValidationIssues{
				ValidationIssue{
					component: "component1",
					message:   "error 1",
					severity:  ErrorSeverityCritical,
				},
				ValidationIssue{
					code:     "errcode1",
					message:  "error message 1",
					severity: ErrorSeverityCritical,
				},
				ValidationIssue{
					code:     "errcode2",
					message:  "error message 2",
					severity: ErrorSeverityWarning,
				},
			},
		},
		{
			name: "nested and wrapped with unknown",
			err: fmt.Errorf("test: %w",
				errors.Join(
					ErrorWithComponent("component1",
						errors.New("error 1"),
					),
					ErrorWithComponent("component2",
						ErrorWithFieldPrefix(NewFieldSelectorGroup(NewFieldSelector("prefix")),
							errors.Join(
								NewValidationIssue("errcode1", "error message 1",
									WithFieldString("field1"),
									WithCriticalSeverity(),
								),
								NewValidationIssue("errcode2", "error message 2",
									WithFieldString("field2"),
									WithWarningSeverity(),
								),
								ErrorWithFieldPrefix(NewFieldSelectorGroup(NewFieldSelector("prefix2")),
									ErrorWithComponent("component3",
										errors.Join(
											NewValidationIssue("errcode3", "error message 3",
												WithFieldString("field3"),
												WithCriticalSeverity(),
											),
											NewValidationIssue("errcode4", "error message 4",
												WithField(
													NewFieldSelector("prefix3"),
													NewFieldSelector("field4"),
												),
												WithWarningSeverity(),
												WithAttributes(Attributes{
													"attr1": "value1",
												}),
											),
										),
									),
								),
							),
						),
					),
					NewValidationIssue("errcode5", "error message 5",
						WithField(NewFieldSelector("field5")),
						WithCriticalSeverity(),
						WithComponent("component4"),
					),
				),
			),
			expectError: false,
			expectedIssues: ValidationIssues{
				ValidationIssue{
					component: "component1",
					message:   "error 1",
					severity:  ErrorSeverityCritical,
				},
				ValidationIssue{
					code:      "errcode1",
					component: "component2",
					message:   "error message 1",
					field: NewFieldSelectorGroup(
						NewFieldSelector("prefix"),
						NewFieldSelector("field1"),
					),
					severity: ErrorSeverityCritical,
				},
				ValidationIssue{
					code:      "errcode2",
					component: "component2",
					message:   "error message 2",
					field: NewFieldSelectorGroup(
						NewFieldSelector("prefix"),
						NewFieldSelector("field2"),
					),
					severity: ErrorSeverityWarning,
				},
				ValidationIssue{
					code:      "errcode3",
					component: "component3",
					message:   "error message 3",
					field: NewFieldSelectorGroup(
						NewFieldSelector("prefix"),
						NewFieldSelector("prefix2"),
						NewFieldSelector("field3"),
					),
					severity: ErrorSeverityCritical,
				},
				ValidationIssue{
					code:      "errcode4",
					component: "component3",
					message:   "error message 4",
					field: NewFieldSelectorGroup(
						NewFieldSelector("prefix"),
						NewFieldSelector("prefix2"),
						NewFieldSelector("prefix3"),
						NewFieldSelector("field4"),
					),
					severity: ErrorSeverityWarning,
					attributes: Attributes{
						"attr1": "value1",
					},
				},
				ValidationIssue{
					code:      "errcode5",
					component: "component4",
					message:   "error message 5",
					field: NewFieldSelectorGroup(
						NewFieldSelector("field5"),
					),
					severity: ErrorSeverityCritical,
				},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			actual, err := AsValidationIssues(test.err)

			if test.expectError {
				require.EqualErrorf(t, err, test.err.Error(), "error must match")
			} else {
				require.NoError(t, err, "error must be nil")
			}

			RequireValidationIssuesMatch(t, test.expectedIssues, actual)
		})
	}
}

func TestValidationIssues_AsError(t *testing.T) {
	issues := ValidationIssues{
		{
			severity:  ErrorSeverityCritical,
			message:   "error1",
			component: "component1",
			field:     NewFieldSelectorGroup(NewFieldSelector("field1")),
		},
	}

	err := issues.AsError()

	validationIssues, err := AsValidationIssues(err)
	require.NoError(t, err)
	RequireValidationIssuesMatch(t, issues, validationIssues)
}

func TestAsValidationIssues_PointerValidationIssue(t *testing.T) {
	issue := NewValidationIssue("errcode1", "error message 1",
		WithFieldString("field1"),
		WithWarningSeverity(),
		WithAttributes(Attributes{
			"attr1": "value1",
		}),
	)

	actual, err := AsValidationIssues(&issue)
	require.NoError(t, err)

	RequireValidationIssuesMatch(t, ValidationIssues{issue}, actual)
}