import json2 as json
import time
import math.big

type StrAlias = string
type BoolAlias = bool
type IntAlias = int
type FloatAlias = f64

enum TestEnum {
	a
	b  @[json: 'BBB']
	c = 10
	d  @[badattr: 'bad'; foobar]
}

type EnumAlias = TestEnum

@[json_as_number]
enum NumberedTestEnum {
	a
	b = 5
}

type Sum = int | string
type SumAlias = Sum

struct Basic {
	a int
	b string
	c bool
}

struct NumberedEnumWrap {
	a NumberedTestEnum
}

type BasicAlias = Basic

struct Opt {
	a ?int
}

type OptAlias = Opt

struct OptRequiered {
	a ?int @[required]
}

type OptRequieredAlias = OptRequiered

struct CustomString {
	data string
}

pub fn (cs CustomString) to_json() string {
	return '"<<<' + cs.data + '>>>"'
}

type CustomStringAlias = CustomString

type NullAlias = json.Null

type TimeAlias = time.Time

type BigAlias = big.Integer

struct NamedFields {
	a    int    @[json: 'id']
	name string @[json: 'Name']
}

type NamedFieldsAlias = NamedFields

struct SkipFields {
	a    int    @[json: '-']
	name string @[skip]
}

type SkipFieldsAlias = SkipFields

struct SkipSomeFields {
	a    int    @[json: '-']
	name string @[skip]
	hi   bool = true
}

type SkipSomeFieldsAlias = SkipSomeFields

struct PointerFields {
	next &PointerFields = unsafe { nil }
	data int
}

type PointerFieldsAlias = PointerFields

struct F64ArrayRoundtripPayload {
	arr []f64
}

struct OmitFields {
	a ?bool   @[omitempty]
	b string  @[omitempty]
	c int     @[omitempty]
	d f64     @[omitempty]
	e ?string = '' @[omitempty]
	f ?int    = 0    @[omitempty]
	g ?f64    = 0.0    @[omitempty]
}

type OmitFieldsAlias = OmitFields

struct OmitemptyRegressionNumber {
	min int
	max int
}

struct OmitemptyRegressionResp {
	options  []string                   @[omitempty]
	metadata map[string]string          @[omitempty]
	number   &OmitemptyRegressionNumber = unsafe { nil } @[omitempty]
	config   ?OmitemptyRegressionNumber @[omitempty]
}

fn test_primitives() {
	assert json.encode('hello') == '"hello"'
	assert json.encode(StrAlias('hello')) == '"hello"'
	assert json.encode(true) == 'true'
	assert json.encode(BoolAlias(false)) == 'false'
	assert json.encode(-12345) == '-12345'
	assert json.encode(IntAlias(-12345)) == '-12345'
	assert json.encode(123.323) == '123.323'
	assert json.encode(FloatAlias(123.323)) == '123.323'
}

fn test_encode_decode_struct_with_f64_array_roundtrips() ! {
	original := F64ArrayRoundtripPayload{
		arr: [0.9716157205240175, 0.9336099585062241]
	}
	encoded := json.encode(original)
	assert encoded == '{"arr":[0.9716157205240175,0.9336099585062241]}'
	assert json.decode[F64ArrayRoundtripPayload](encoded)! == original
}

fn test_arrays() {
	assert json.encode([1, 2, 3, 4]) == '[1,2,3,4]'
}

fn test_maps() {
	assert json.encode({
		'hi':  0
		'bye': 1
	}) == '{"hi":0,"bye":1}'
}

fn test_enums() {
	assert json.encode(TestEnum.c) == '"c"'
	assert json.encode(EnumAlias(TestEnum.c)) == '"c"'
	assert json.encode(TestEnum.c, enum_as_int: true) == '10'
	assert json.encode(EnumAlias(TestEnum.c), enum_as_int: true) == '10'
	assert json.encode(TestEnum.b) == '"BBB"'
	assert json.encode(EnumAlias(TestEnum.b)) == '"BBB"'
	// Ensure that only `json: ` attrs is applied
	assert json.encode(TestEnum.d) == '"d"'
	assert json.encode(EnumAlias(TestEnum.d)) == '"d"'
}

fn test_enum_json_as_number_attribute() {
	assert json.encode(NumberedTestEnum.a) == '0'
	assert json.encode(NumberedTestEnum.b) == '5'
	assert json.encode(NumberedEnumWrap{
		a: .a
	}) == '{"a":0}'
}

fn test_sumtypes() {
	assert json.encode(Sum(10)) == '10'
	assert json.encode(Sum('hi')) == '"hi"'
	assert json.encode(SumAlias(10)) == '10'
	assert json.encode(SumAlias('hi')) == '"hi"'
}

fn test_basic_structs() {
	assert json.encode(Basic{
		a: 10
		b: 'hi'
		c: true
	}) == '{"a":10,"b":"hi","c":true}'

	assert json.encode(BasicAlias{
		a: 10
		b: 'hi'
		c: true
	}) == '{"a":10,"b":"hi","c":true}'
}

fn test_nested() {
	assert json.encode([
		{
			'hi':  Basic{ a: 1, b: 'a', c: false }
			'bye': Basic{
				a: 2
				b: 'b'
				c: true
			}
		},
		{
			'hi2':  Basic{
				a: 3
				b: 'c'
				c: false
			}
			'bye2': Basic{
				a: 4
				b: 'd'
				c: true
			}
		},
	]) == '[{"hi":{"a":1,"b":"a","c":false},"bye":{"a":2,"b":"b","c":true}},{"hi2":{"a":3,"b":"c","c":false},"bye2":{"a":4,"b":"d","c":true}}]'
	assert json.encode([
		{
			'hi':  Basic{ a: 1, b: 'a', c: false }
			'bye': Basic{
				a: 2
				b: 'b'
				c: true
			}
		},
		{
			'hi2':  Basic{
				a: 3
				b: 'c'
				c: false
			}
			'bye2': Basic{
				a: 4
				b: 'd'
				c: true
			}
		},
	],
		prettify: true
	) == '[
    {
        "hi": {
            "a": 1,
            "b": "a",
            "c": false
        },
        "bye": {
            "a": 2,
            "b": "b",
            "c": true
        }
    },
    {
        "hi2": {
            "a": 3,
            "b": "c",
            "c": false
        },
        "bye2": {
            "a": 4,
            "b": "d",
            "c": true
        }
    }
]'
}

fn test_string_escapes() {
	assert json.encode('normal escapes: ", \\ special control escapes: \b, \n, \f, \t, \r, other control escapes: \0, \u001b') == r'"normal escapes: \", \\ special control escapes: \b, \n, \f, \t, \r, other control escapes: \u0000, \u001b"'
	assert json.encode('ascii, é, 한, 😀, ascii') == r'"ascii, é, 한, 😀, ascii"'
	assert json.encode('ascii, é, 한, 😀, ascii', escape_unicode: true) == r'"ascii, \u00e9, \ud55c, \uD83D\ude00, ascii"'
}

fn test_options() {
	assert json.encode(Opt{none}) == '{}'
	assert json.encode(Opt{99}) == '{"a":99}'
	assert json.encode(OptAlias{none}) == '{}'
	assert json.encode(OptAlias{99}) == '{"a":99}'

	assert json.encode(OptRequiered{none}) == '{"a":null}'
	assert json.encode(OptRequiered{99}) == '{"a":99}'
	assert json.encode(OptRequieredAlias{none}) == '{"a":null}'
	assert json.encode(OptRequieredAlias{99}) == '{"a":99}'
}

fn test_custom_encoders() {
	assert json.encode(CustomString{'hi'}) == '"<<<hi>>>"'
	assert json.encode(CustomStringAlias{'hi'}) == '"<<<hi>>>"'

	assert json.encode(json.Null{}) == 'null'
	assert json.encode(NullAlias{}) == 'null'

	assert json.encode(time.Time{}) == '"0000-01-01T00:00:00.000Z"'
	assert json.encode(TimeAlias{}) == '"0000-01-01T00:00:00.000Z"'

	assert json.encode(big.integer_from_i64(1234567890)) == '1234567890'
	assert json.encode(BigAlias(big.integer_from_i64(1234567890))) == '1234567890'
}

fn test_named_fields() {
	assert json.encode(NamedFields{ a: 1, name: 'john' }) == '{"id":1,"Name":"john"}'
	assert json.encode(NamedFieldsAlias{ a: 1, name: 'john' }) == '{"id":1,"Name":"john"}'
}

fn test_skip_fields() {
	assert json.encode(SkipFields{ a: 1, name: 'john' }) == '{}'
	assert json.encode(SkipFieldsAlias{ a: 1, name: 'john' }) == '{}'
	assert json.encode(SkipFields{ a: 1, name: 'john' },
		prettify: true
	) == '{}'

	assert json.encode(SkipSomeFields{ a: 1, name: 'john' }) == '{"hi":true}'
	assert json.encode(SkipSomeFieldsAlias{ a: 1, name: 'john' }) == '{"hi":true}'
	assert json.encode(SkipSomeFields{ a: 1, name: 'john' },
		prettify: true
	) == '{
    "hi": true
}'
}

fn test_omit_fields() {
	assert json.encode(OmitFields{}) == '{}'
	assert json.encode(OmitFieldsAlias{}) == '{}'

	r1 := OmitemptyRegressionResp{
		options: ['first', 'second']
	}
	r2 := OmitemptyRegressionResp{
		number: &OmitemptyRegressionNumber{0, 0}
	}
	r3 := OmitemptyRegressionResp{
		metadata: {
			'kind': 'test'
		}
	}
	assert json.encode(r1) == '{"options":["first","second"]}'
	assert json.encode(r2) == '{"number":{"min":0,"max":0}}'
	assert json.encode(r3) == '{"metadata":{"kind":"test"}}'
	assert json.encode(OmitemptyRegressionResp{}) == '{}'
	assert json.encode(OmitemptyRegressionResp{
		config: OmitemptyRegressionNumber{
			min: 1
			max: 2
		}
	}) == '{"config":{"min":1,"max":2}}'
}

fn test_pointer_fields() {
	assert json.encode(PointerFields{
		next: &PointerFields{
			next: &PointerFields{
				next: &PointerFields{
					data: 4
				}
				data: 3
			}
			data: 2
		}
		data: 1
	}) == '{"next":{"next":{"next":{"data":4},"data":3},"data":2},"data":1}'
	assert json.encode(PointerFieldsAlias{
		next: &PointerFieldsAlias{
			next: &PointerFieldsAlias{
				next: &PointerFieldsAlias{
					data: 4
				}
				data: 3
			}
			data: 2
		}
		data: 1
	}) == '{"next":{"next":{"next":{"data":4},"data":3},"data":2},"data":1}'
	assert json.encode(PointerFields{
		next: &PointerFields{
			next: &PointerFields{
				next: &PointerFields{
					data: 4
				}
				data: 3
			}
			data: 2
		}
		data: 1
	},
		prettify: true
	) == '{
    "next": {
        "next": {
            "next": {
                "data": 4
            },
            "data": 3
        },
        "data": 2
    },
    "data": 1
}'
}