// Copyright 2026 Dolthub, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package _go

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

	"github.com/cockroachdb/apd/v3"
	gmstypes "github.com/dolthub/go-mysql-server/sql/types"
	"github.com/stretchr/testify/require"

	"github.com/dolthub/doltgresql/server/types"
)

// TestLegacyJsonBRoundTrip verifies that JSONB values written in the old ExtendedEnc format
// (used before JsonAdaptiveEnc was introduced for jsonb columns) deserialize correctly.
// Each JSON value type is tested to ensure no internal JsonValue* types leak into the result.
func TestLegacyJsonBRoundTrip(t *testing.T) {
	tests := []struct {
		name     string
		input    any // value placed into JSONDocument.Val before serialization
		expected any // expected JSONDocument.Val after deserialization
	}{
		// ── Primitives ────────────────────────────────────────────────────────────────
		{
			name:     "null",
			input:    nil,
			expected: nil,
		},
		{
			name:     "bool_true",
			input:    true,
			expected: true,
		},
		{
			name:     "bool_false",
			input:    false,
			expected: false,
		},
		{
			name:     "string",
			input:    "hello",
			expected: "hello",
		},
		{
			name:     "string_empty",
			input:    "",
			expected: "",
		},
		{
			name:     "string_unicode",
			input:    "こんにちは",
			expected: "こんにちは",
		},
		// Numbers: the primary compatibility concern — must come back as *apd.Decimal,
		// not the internal JsonValueNumber type.
		{
			name:     "number_zero",
			input:    json.Number("0"),
			expected: mustDecimal("0"),
		},
		{
			name:     "number_integer",
			input:    json.Number("42"),
			expected: mustDecimal("42"),
		},
		{
			name:     "number_negative_integer",
			input:    json.Number("-7"),
			expected: mustDecimal("-7"),
		},
		{
			name:     "number_float",
			input:    json.Number("3.14"),
			expected: mustDecimal("3.14"),
		},
		{
			name:     "number_negative_float",
			input:    json.Number("-2.718"),
			expected: mustDecimal("-2.718"),
		},
		{
			name:     "number_large_integer",
			input:    json.Number("99999999999999999999"),
			expected: mustDecimal("99999999999999999999"),
		},
		{
			name:     "number_high_precision",
			input:    json.Number("1.23456789012345678901"),
			expected: mustDecimal("1.23456789012345678901"),
		},
		// ── Empty containers ──────────────────────────────────────────────────────────
		{
			name:     "object_empty",
			input:    map[string]any{},
			expected: map[string]any{},
		},
		{
			name:     "array_empty",
			input:    []any{},
			expected: []any{},
		},
		// ── Objects: one test per value type ─────────────────────────────────────────
		{
			name:     "object_string_val",
			input:    map[string]any{"k": "v"},
			expected: map[string]any{"k": "v"},
		},
		{
			name:     "object_number_val",
			input:    map[string]any{"n": json.Number("99")},
			expected: map[string]any{"n": mustDecimal("99")},
		},
		{
			name:     "object_bool_val",
			input:    map[string]any{"b": true},
			expected: map[string]any{"b": true},
		},
		{
			name:     "object_null_val",
			input:    map[string]any{"n": nil},
			expected: map[string]any{"n": nil},
		},
		{
			name: "object_mixed_vals",
			input: map[string]any{
				"s": "hello", "n": json.Number("1.5"), "b": false, "z": nil,
			},
			expected: map[string]any{
				"s": "hello", "n": mustDecimal("1.5"), "b": false, "z": nil,
			},
		},
		// ── Arrays: one test per value type ──────────────────────────────────────────
		{
			name:     "array_strings",
			input:    []any{"a", "b", "c"},
			expected: []any{"a", "b", "c"},
		},
		{
			name:     "array_numbers",
			input:    []any{json.Number("1"), json.Number("2"), json.Number("3")},
			expected: []any{mustDecimal("1"), mustDecimal("2"), mustDecimal("3")},
		},
		{
			name:     "array_bools",
			input:    []any{true, false, true},
			expected: []any{true, false, true},
		},
		{
			name:     "array_nulls",
			input:    []any{nil, nil},
			expected: []any{nil, nil},
		},
		{
			name:     "array_mixed",
			input:    []any{json.Number("1"), "two", true, nil},
			expected: []any{mustDecimal("1"), "two", true, nil},
		},
		// ── Nested structures ─────────────────────────────────────────────────────────
		{
			name: "object_with_nested_array",
			input: map[string]any{
				"nums": []any{json.Number("1"), json.Number("2")},
				"name": "test",
			},
			expected: map[string]any{
				"nums": []any{mustDecimal("1"), mustDecimal("2")},
				"name": "test",
			},
		},
		{
			name: "array_of_objects",
			input: []any{
				map[string]any{"x": json.Number("10")},
				map[string]any{"x": json.Number("20")},
			},
			expected: []any{
				map[string]any{"x": mustDecimal("10")},
				map[string]any{"x": mustDecimal("20")},
			},
		},
		{
			name: "deeply_nested",
			input: map[string]any{
				"a": map[string]any{
					"b": []any{
						json.Number("1"),
						map[string]any{"c": true, "d": json.Number("-9.9")},
						[]any{"x", json.Number("0")},
					},
				},
			},
			expected: map[string]any{
				"a": map[string]any{
					"b": []any{
						mustDecimal("1"),
						map[string]any{"c": true, "d": mustDecimal("-9.9")},
						[]any{"x", mustDecimal("0")},
					},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			doc := gmstypes.JSONDocument{Val: tt.input}

			// Simulate writing with old Doltgres (ExtendedEnc path calls serializeTypeJsonB).
			serialized, err := types.JsonB.SerializeValue(context.Background(), doc)
			require.NoError(t, err)

			// Simulate reading with new Doltgres (still calls deserializeTypeJsonB for old rows).
			result, err := types.JsonB.DeserializeValue(context.Background(), serialized)
			require.NoError(t, err)
			require.NotNil(t, result)

			resultDoc, ok := result.(gmstypes.JSONDocument)
			require.True(t, ok)
			requireNoInternalJsonTypes(t, resultDoc.Val)
			requireJsonEqual(t, tt.expected, resultDoc.Val)
		})
	}
}

// requireNoInternalJsonTypes recurses through a deserialized JSON value and asserts that no
// internal JsonValue* types have leaked out. Every value must be a native Go type.
func requireNoInternalJsonTypes(t *testing.T, val any) {
	t.Helper()
	switch v := val.(type) {
	case map[string]any:
		for _, child := range v {
			requireNoInternalJsonTypes(t, child)
		}
	case []any:
		for _, item := range v {
			requireNoInternalJsonTypes(t, item)
		}
	case types.JsonValueNumber:
		t.Errorf("number leaked as internal JsonValueNumber; expected *apd.Decimal")
	case types.JsonValueString:
		t.Errorf("string leaked as internal JsonValueString; expected string")
	case types.JsonValueBoolean:
		t.Errorf("bool leaked as internal JsonValueBoolean; expected bool")
	case types.JsonValueNull:
		t.Errorf("null leaked as internal JsonValueNull; expected nil")
	case types.JsonValueObject:
		t.Errorf("object leaked as internal JsonValueObject; expected map[string]any")
	case types.JsonValueArray:
		t.Errorf("array leaked as internal JsonValueArray; expected []any")
	}
}

// requireJsonEqual recursively compares an expected JSON value tree against actual,
// using string comparison for *apd.Decimal to avoid representation sensitivity.
func requireJsonEqual(t *testing.T, expected, actual any) {
	t.Helper()
	if expected == nil {
		require.Nil(t, actual, "expected nil, got %T: %v", actual, actual)
		return
	}
	switch e := expected.(type) {
	case *apd.Decimal:
		a, ok := actual.(*apd.Decimal)
		require.True(t, ok, "expected *apd.Decimal, got %T: %v", actual, actual)
		require.Equal(t, e.String(), a.String())
	case map[string]any:
		a, ok := actual.(map[string]any)
		require.True(t, ok, "expected map[string]any, got %T", actual)
		require.Equal(t, len(e), len(a), "object has %d keys, want %d", len(a), len(e))
		for k, ev := range e {
			av, exists := a[k]
			require.True(t, exists, "key %q missing from result", k)
			requireJsonEqual(t, ev, av)
		}
	case []any:
		a, ok := actual.([]any)
		require.True(t, ok, "expected []any, got %T", actual)
		require.Equal(t, len(e), len(a), "array has %d elements, want %d", len(a), len(e))
		for i := range e {
			requireJsonEqual(t, e[i], a[i])
		}
	default:
		require.Equal(t, expected, actual)
	}
}

// TestLegacyJsonBReserialization verifies that a value deserialized from the legacy
// ExtendedEnc format can be re-serialized without error. This exercises the path where
// serializeTypeJsonB receives a JSONDocument whose Val contains *apd.Decimal (the type
// that jsonValueToInterface now returns for JsonValueNumber after the bugfix), and
// ConvertToJsonDocument must handle it.
func TestLegacyJsonBReserialization(t *testing.T) {
	tests := []struct {
		name  string
		input any
	}{
		{"number_integer", json.Number("42")},
		{"number_negative", json.Number("-7")},
		{"number_float", json.Number("3.14")},
		{"number_large", json.Number("99999999999999999999")},
		{"object_with_number", map[string]any{"n": json.Number("99")}},
		{"array_with_numbers", []any{json.Number("1"), json.Number("2"), json.Number("3")}},
		{"nested_number", map[string]any{"a": map[string]any{"b": json.Number("1.5")}}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			doc := gmstypes.JSONDocument{Val: tt.input}

			// Step 1: serialize (simulates old Doltgres write using the legacy ExtendedEnc path)
			serialized, err := types.JsonB.SerializeValue(context.Background(), doc)
			require.NoError(t, err)

			// Step 2: deserialize (jsonValueToInterface now returns *apd.Decimal for numbers)
			deserialized, err := types.JsonB.DeserializeValue(context.Background(), serialized)
			require.NoError(t, err)
			require.NotNil(t, deserialized)

			// Step 3: re-serialize the deserialized value.
			_, err = types.JsonB.SerializeValue(context.Background(), deserialized)
			require.NoError(t, err, "re-serializing a deserialized legacy JSONB value must not fail")
		})
	}
}

// mustDecimal parses s into an *apd.Decimal, panicking on failure.
func mustDecimal(s string) *apd.Decimal {
	d := new(apd.Decimal)
	if err := d.Scan(s); err != nil {
		panic(fmt.Sprintf("mustDecimal(%q): %v", s, err))
	}
	return d
}