import x.json2 as json
import time
import math

const fixed_time = time.new(
	year:   2022
	month:  3
	day:    11
	hour:   13
	minute: 54
	second: 25
)

type StringAlias = string
type BoolAlias = bool
type IntAlias = int
type TimeAlias = time.Time
type StructAlias = StructType[int]
type EnumAlias = Enumerates

type SumTypes = StructType[string] | []SumTypes | []string | bool | string | time.Time | u32

enum Enumerates {
	a
	b
	c
	d
	e = 99
	f
}

struct StructType[T] {
mut:
	val T
}

struct StructTypeOption[T] {
mut:
	val ?T
}

struct StructTypePointer[T] {
mut:
	val &T
}

fn test_types() {
	assert json.decode[StructType[string]]('{"val": ""}')!.val == ''

	assert json.decode[StructType[string]]('{"val": "2"}')!.val == '2'

	assert json.decode[StructType[int]]('{"val": 2}')!.val == 2

	assert json.decode[StructType[map[string]string]]('{"val": {"val1": "test"}}')!.val['val1'] == 'test'

	assert json.decode[StructType[Enumerates]]('{"val": 0}')!.val == Enumerates.a
	assert json.decode[StructType[Enumerates]]('{"val": 1}')!.val == Enumerates.b

	assert json.decode[StructType[time.Time]]('{"val": "2022-03-11T13:54:25.000Z"}')!.val == fixed_time
	assert json.decode[StructType[time.Time]]('{"val": "2022-03-11T13:54:25.000Z"}')!.val.unix() == fixed_time.unix()
}

fn test_option_types() {
	if x := json.decode[StructTypeOption[string]]('{}')!.val {
		assert false, 'Should return none'
	} else {
		assert err.msg() == ''
		assert true
	}

	if x := json.decode[StructTypeOption[string]]('{"val": "2"}')!.val {
		assert x == '2'
	} else {
		assert false, 'Should not return none'
	}
}

// Test structure for basic number types
struct JsonNumbers {
	val_i8  i8
	val_i16 i16
	val_i32 i32
	val_i64 i64
	val_u8  u8
	val_u16 u16
	val_u32 u32
	val_u64 u64
	val_int int
	val_f32 f32
	val_f64 f64
}

// Test structure for float precision
struct JsonFloats {
	val_f32 f32
	val_f64 f64
}

// Test basic functionality
struct JsonU8 {
	val1 u8
	val2 u8
}

fn test_u8_values() {
	x := JsonU8{
		val1: 58
		val2: 58
	}

	str := json.encode(x)
	y := json.decode[JsonU8](str) or { panic(err) }
	assert x == y
	println('✓ Basic u8 test passed')
}

fn test_all_number_types() {
	// Test normal range values
	x := JsonNumbers{
		val_i8:  -100
		val_i16: -1000
		val_i32: -100000
		val_i64: -1000000000
		val_u8:  58
		val_u16: 2000
		val_u32: 200000
		val_u64: 2000000000
		val_int: 300000
		val_f32: 3.14
		val_f64: 2.71828
	}

	str := json.encode(x)
	y := json.decode[JsonNumbers](str) or { panic('Decoding failed: ${err}') }

	assert x.val_i8 == y.val_i8
	assert x.val_i16 == y.val_i16
	assert x.val_i32 == y.val_i32
	assert x.val_i64 == y.val_i64
	assert x.val_u8 == y.val_u8
	assert x.val_u16 == y.val_u16
	assert x.val_u32 == y.val_u32
	assert x.val_u64 == y.val_u64
	assert x.val_int == y.val_int
	assert math.alike(x.val_f32, y.val_f32)
	assert math.alike(x.val_f64, y.val_f64)

	println('✓ All number types test passed')
}

fn test_number_boundaries() {
	// Test minimum and maximum values for various types
	test_cases := [
		json.encode(JsonU8{ val1: 0, val2: 255 }),
		json.encode(JsonU8{ val1: u8(128), val2: u8(255) }),
		'{"min_i8": -128, "max_i8": 127}',
		'{"min_u8": 0, "max_u8": 255}',
		'{"zero": 0}',
	]!

	for case in test_cases {
		result := json.decode[JsonU8](case)!
		assert result.val1 >= 0 && result.val1 <= 255
		assert result.val2 >= 0 && result.val2 <= 255
	}
	println('✓ Boundary values test passed')
}

fn test_quoted_numbers_in_strict_mode() {
	quoted_number_cases := [
		'{"val1": "123", "val2": "45"}',
		'{"val1": 123, "val2": "45"}',
		'{"val1": "255", "val2": 0}',
	]!

	for case in quoted_number_cases {
		json.decode[JsonU8](case, strict: true) or { continue }
		panic('Expected decoding to fail for quoted number in strict mode but succeeded: ${case}')
	}
	println('✓ Quoted numbers correctly rejected in strict mode test passed')
}

fn test_quoted_numbers_in_default_mode() {
	assert json.decode[JsonU8]('{"val1": "123", "val2": "45"}')! == JsonU8{
		val1: 123
		val2: 45
	}
	assert json.decode[JsonU8]('{"val1": 123, "val2": "45"}')! == JsonU8{
		val1: 123
		val2: 45
	}
	println('✓ Quoted numbers accepted in default mode test passed')
}

fn test_error_conditions() {
	// Test invalid inputs that should trigger errors
	invalid_cases := [
		'{"val1": "abc", "val2": 58}', // Non-numeric string
		'{"val1": "", "val2": 58}', // Empty string
		'{"val1": 300, "val2": 58}', // Out of u8 range (300 > 255)
		'{"val1": -1, "val2": 58}', // Negative value for u8
		'{"val1": 123.45, "val2": 58}', // Float for integer type
	]!

	mut error_count := 0
	for case in invalid_cases {
		result := json.decode[JsonU8](case) or {
			error_count++
			continue // Expected failure, error handling works correctly
		}
		// If we reach here, it means decoding succeeded when it should have failed
		panic('Expected decoding to fail but succeeded: ${case}')
	}
	assert error_count > 0 // Ensure we caught some errors
	println('✓ Error handling test passed')
}

fn test_float_precision() {
	// Test floating point precision and scientific notation
	test_cases := [
		JsonFloats{
			val_f32: 3.14159265
			val_f64: 2.718281828459045
		},
		JsonFloats{
			val_f32: 1.0e10
			val_f64: 1.0e-10
		},
		JsonFloats{
			val_f32: -123.456
			val_f64: -789.012
		},
		JsonFloats{
			val_f32: 0.0
			val_f64: 0.0
		},
	]!

	for x in test_cases {
		str := json.encode(x)
		y := json.decode[JsonFloats](str) or { panic('Float decoding failed: ${err}') }

		// Use relative error for assertions
		assert math.alike(y.val_f32, x.val_f32)
		assert math.alike(y.val_f64, x.val_f64)
	}
	println('✓ Float precision test passed')
}

fn test_performance_large_scale() {
	// Performance test: decode large numbers of values
	mut total := u64(0)

	for i in 0 .. 1000 {
		x := JsonU8{
			val1: u8(i % 256)
			val2: u8((i * 7) % 256)
		}
		str := json.encode(x)
		y := json.decode[JsonU8](str) or { panic('Performance test decoding failed: ${err}') }
		total += y.val1 + y.val2
	}

	assert total > 0 // Ensure the loop executed
	println('✓ Performance test passed')
}

fn test_special_float_values() {
	// Test special float values

	// Json does not support nan, +-inf yet
	assert json.encode(math.nan()) == 'nan'
	assert json.encode(math.inf(1)) == '+inf'
	assert json.encode(math.inf(-1)) == '-inf'

	println('✓ Special float values test passed')
}

fn test_json_format_consistency() {
	// Test that encoding and decoding preserves data integrity
	original := JsonNumbers{
		val_i8:  100
		val_i16: 1000
		val_i32: 100000
		val_i64: 1000000000
		val_u8:  33
		val_u16: 2000
		val_u32: 200000
		val_u64: 2000000000
		val_int: 300000
		val_f32: 3.14
		val_f64: 2.71828
	}

	// Encode and decode multiple times
	str1 := json.encode(original)
	decoded1 := json.decode[JsonNumbers](str1) or { panic('First decode failed: ${err}') }
	str2 := json.encode(decoded1)
	decoded2 := json.decode[JsonNumbers](str2) or { panic('Second decode failed: ${err}') }

	// All versions should be equivalent
	assert decoded1 == decoded2
	println('✓ JSON format consistency test passed')
}