package enums

import (
	"encoding/json"
	"reflect"
	"testing"
)

type mockEnum struct {
	name string
}

func (m mockEnum) Valid() bool                  { return m.name != "" }
func (m mockEnum) ValuesAny() []any              { return []any{mockEnum{name: "a"}, mockEnum{name: "b"}} }
func (m mockEnum) ValuesMeta() []EnumMetaValue   { return nil }
func (m mockEnum) VarName() string               { return m.name }
func (m mockEnum) TypeName() string              { return "mockEnum" }
func (m mockEnum) PackageName() string           { return "enums_test" }
func (m mockEnum) String() string                { return "str:" + m.name }
func (m mockEnum) Description() string           { return "desc:" + m.name }
func (m mockEnum) DescriptionMeta() EnumDescriptionMetaValue {
	return EnumDescriptionMetaValue{VarName: m.name, Value: m, Description: "desc:" + m.name}
}

func (m mockEnum) MarshalJSON() ([]byte, error) {
	return json.Marshal(m.name)
}

func TestMockEnumImplementsInterfaces(t *testing.T) {
	var _ Enum = mockEnum{}
	var _ StringEnum = mockEnum{}
	var _ DescriptionEnum = mockEnum{}
}

func TestEnumValid(t *testing.T) {
	if !(mockEnum{name: "x"}).Valid() {
		t.Errorf("expected Valid() == true")
	}
	if (mockEnum{}).Valid() {
		t.Errorf("expected Valid() == false for zero value")
	}
}

func TestEnumMetaValueJSON(t *testing.T) {
	desc := "the-description"
	mv := EnumMetaValue{
		VarName:     "Foo",
		Value:       mockEnum{name: "foo"},
		Description: &desc,
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["varName"] != "Foo" {
		t.Errorf("varName == %v, want Foo", got["varName"])
	}
	if got["value"] != "foo" {
		t.Errorf("value == %v, want foo", got["value"])
	}
	if got["description"] != "the-description" {
		t.Errorf("description == %v, want the-description", got["description"])
	}
}

func TestEnumMetaValueJSONNilDescription(t *testing.T) {
	mv := EnumMetaValue{
		VarName:     "Foo",
		Value:       mockEnum{name: "foo"},
		Description: nil,
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["description"] != nil {
		t.Errorf("description == %v, want nil", got["description"])
	}
}

func TestEnumDescriptionMetaValueJSON(t *testing.T) {
	mv := EnumDescriptionMetaValue{
		VarName:     "Bar",
		Value:       mockEnum{name: "bar"},
		Description: "bar-desc",
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	expected := map[string]any{
		"varName":     "Bar",
		"value":       "bar",
		"description": "bar-desc",
	}
	if !reflect.DeepEqual(got, expected) {
		t.Errorf("json output == %v, want %v", got, expected)
	}
}

func TestEnumDataMetaValueMarshalJSON(t *testing.T) {
	desc := "data-desc"
	mv := EnumDataMetaValue{
		VarName:     "Baz",
		Value:       mockEnum{name: "baz"},
		Description: &desc,
		Data: map[string]any{
			"extra1": "hello",
			"extra2": float64(42),
		},
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["varName"] != "Baz" {
		t.Errorf("varName == %v, want Baz", got["varName"])
	}
	if got["value"] != "baz" {
		t.Errorf("value == %v, want baz", got["value"])
	}
	if got["description"] != "data-desc" {
		t.Errorf("description == %v, want data-desc", got["description"])
	}
	if got["extra1"] != "hello" {
		t.Errorf("extra1 == %v, want hello", got["extra1"])
	}
	if got["extra2"] != float64(42) {
		t.Errorf("extra2 == %v, want 42", got["extra2"])
	}
}

func TestEnumDataMetaValueMarshalJSONNilData(t *testing.T) {
	mv := EnumDataMetaValue{
		VarName:     "Baz",
		Value:       mockEnum{name: "baz"},
		Description: nil,
		Data:        nil,
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["varName"] != "Baz" {
		t.Errorf("varName == %v, want Baz", got["varName"])
	}
	if got["value"] != "baz" {
		t.Errorf("value == %v, want baz", got["value"])
	}
	if _, ok := got["description"]; !ok {
		t.Errorf("description key missing in JSON output")
	}
	if got["description"] != nil {
		t.Errorf("description == %v, want nil", got["description"])
	}
	if len(got) != 3 {
		t.Errorf("expected 3 keys with nil Data, got %d: %v", len(got), got)
	}
}

func TestEnumDataMetaValueMarshalJSONDataDoesNotOverrideStandardFields(t *testing.T) {
	desc := "real-desc"
	mv := EnumDataMetaValue{
		VarName:     "Real",
		Value:       mockEnum{name: "real"},
		Description: &desc,
		Data: map[string]any{
			"varName":     "ShouldBeOverwritten",
			"value":       "ShouldBeOverwritten",
			"description": "ShouldBeOverwritten",
			"keep":        "kept",
		},
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["varName"] != "Real" {
		t.Errorf("varName == %v, want Real (standard field must override Data)", got["varName"])
	}
	if got["value"] != "real" {
		t.Errorf("value == %v, want real (standard field must override Data)", got["value"])
	}
	if got["description"] != "real-desc" {
		t.Errorf("description == %v, want real-desc (standard field must override Data)", got["description"])
	}
	if got["keep"] != "kept" {
		t.Errorf("keep == %v, want kept", got["keep"])
	}
}

func TestEnumDataMetaValueMarshalJSONEmptyData(t *testing.T) {
	mv := EnumDataMetaValue{
		VarName:     "E",
		Value:       mockEnum{name: "e"},
		Description: nil,
		Data:        map[string]any{},
	}

	data, err := json.Marshal(mv)
	if err != nil {
		t.Fatalf("json.Marshal failed: %v", err)
	}

	var got map[string]any
	if err := json.Unmarshal(data, &got); err != nil {
		t.Fatalf("json.Unmarshal failed: %v", err)
	}

	if got["varName"] != "E" {
		t.Errorf("varName == %v, want E", got["varName"])
	}
	if got["value"] != "e" {
		t.Errorf("value == %v, want e", got["value"])
	}
}