package jsnum

import (
	"flag"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"slices"
	"testing"

	"efprojects.com/kitten-ipc/kitcom/internal/tsgo/testutil/jstest"
	"github.com/go-json-experiment/json"
	"gotest.tools/v3/assert"
)

type stringTest struct {
	number Number
	str    string
}

var stringTests = slices.Concat([]stringTest{
	{NaN(), "NaN"},
	{Inf(1), "Infinity"},
	{Inf(-1), "-Infinity"},
	{0, "0"},
	{negativeZero, "0"},
	{1, "1"},
	{-1, "-1"},
	{0.3, "0.3"},
	{-0.3, "-0.3"},
	{1.5, "1.5"},
	{-1.5, "-1.5"},
	{1e308, "1e+308"},
	{-1e308, "-1e+308"},
	{math.Pi, "3.141592653589793"},
	{-math.Pi, "-3.141592653589793"},
	{MaxSafeInteger, "9007199254740991"},
	{MinSafeInteger, "-9007199254740991"},
	{numberFromBits(0x000FFFFFFFFFFFFF), "2.225073858507201e-308"},
	{numberFromBits(0x0010000000000000), "2.2250738585072014e-308"},
	{1234567.8, "1234567.8"},
	{19686109595169230000, "19686109595169230000"},
	{123.456, "123.456"},
	{-123.456, "-123.456"},
	{444123, "444123"},
	{-444123, "-444123"},
	{444123.789123456789875436, "444123.7891234568"},
	{-444123.78963636363636363636, "-444123.7896363636"},
	{1e21, "1e+21"},
	{1e20, "100000000000000000000"},
}, ryuTests)

func TestString(t *testing.T) {
	t.Parallel()

	for _, test := range stringTests {
		fInput := float64(test.number)

		t.Run(fmt.Sprintf("%v", fInput), func(t *testing.T) {
			t.Parallel()
			assert.Equal(t, test.number.String(), test.str)
		})
	}
}

var fromStringTests = []stringTest{
	{NaN(), "    NaN"},
	{Inf(1), "Infinity    "},
	{Inf(-1), "    -Infinity"},
	{1, "1."},
	{1, "1.0   "},
	{1, "+1"},
	{1, "+1."},
	{1, "+1.0"},
	{NaN(), "whoops"},
	{0, ""},
	{0, "0"},
	{0, "0."},
	{0, "0.0"},
	{0, "0.0000"},
	{0, ".0000"},
	{negativeZero, "-0"},
	{negativeZero, "-0."},
	{negativeZero, "-0.0"},
	{negativeZero, "-.0"},
	{NaN(), "."},
	{NaN(), "e"},
	{NaN(), ".e"},
	{NaN(), "+"},
	{0, "0X0"},
	{NaN(), "e0"},
	{NaN(), "E0"},
	{NaN(), "1e"},
	{NaN(), "1e+"},
	{NaN(), "1e-"},
	{1, "1e+0"},
	{NaN(), "++0"},
	{NaN(), "0_0"},
	{Inf(1), "1e1000"},
	{Inf(-1), "-1e1000"},
	{0, ".0e0"},
	{NaN(), "0e++0"},
	{10, "0XA"},
	{0b1010, "0b1010"},
	{0b1010, "0B1010"},
	{0o12, "0o12"},
	{0o12, "0O12"},
	{0x123456789abcdef0, "0x123456789abcdef0"},
	{0x123456789abcdef0, "0X123456789ABCDEF0"},
	{18446744073709552000, "0X10000000000000000"},
	{18446744073709597000, "0X1000000000000A801"},
	{NaN(), "0B0.0"},
	{1.231235345083403e+91, "12312353450834030486384068034683603046834603806830644850340602384608368034634603680348603864"},
	{NaN(), "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX8OOOOOOOOOOOOOOOOOOO"},
	{Inf(1), "+Infinity"},
	{1234.56, "  \t1234.56  "},
	{NaN(), "\u200b"},
	{0, " "},
	{0, "\n"},
	{0, "\r"},
	{0, "\r\n"},
	{0, "\u2028"},
	{0, "\u2029"},
	{0, "\t"},
	{0, "\v"},
	{0, "\f"},
	{0, "\uFEFF"},
	{0, "\u00A0"},
	{10000000000000000000, "010000000000000000000"},
	{NaN(), "0x1.fffffffffffffp1023"}, // Make sure Go's extended float syntax doesn't work.
	{NaN(), "0X_1FFFP-16"},
	{NaN(), "1_000"}, // NumberToString doesn't handle underscores.
	{0, "0x0"},
	{0, "0X0"},
	{NaN(), "0xOOPS"},
	{0xABCDEF, "0xABCDEF"},
	{0xABCDEF, "0xABCDEF"},
	{0, "0o0"},
	{0, "0O0"},
	{NaN(), "0o8"},
	{NaN(), "0O8"},
	{0o12345, "0o12345"},
	{0o12345, "0O12345"},
	{0, "0b0"},
	{0, "0B0"},
	{NaN(), "0b2"},
	{NaN(), "0b2"},
	{0b10101, "0b10101"},
	{0b10101, "0B10101"},
	{NaN(), "1.f"},
	{NaN(), "1.e"},
	{NaN(), "1.0ef"},
	{NaN(), "1.0e"},
	{NaN(), ".f"},
	{NaN(), ".e"},
	{NaN(), ".0ef"},
	{NaN(), ".0e"},
	{NaN(), "a.f"},
	{NaN(), "a.e"},
	{NaN(), "a.0ef"},
	{NaN(), "a.0e"},
}

func TestFromString(t *testing.T) {
	t.Parallel()

	t.Run("stringTests", func(t *testing.T) {
		t.Parallel()
		for _, test := range stringTests {
			t.Run(test.str, func(t *testing.T) {
				t.Parallel()
				assertEqualNumber(t, FromString(test.str), test.number)
				assertEqualNumber(t, FromString(test.str+" "), test.number)
				assertEqualNumber(t, FromString(" "+test.str), test.number)
			})
		}
	})

	t.Run("fromStringTests", func(t *testing.T) {
		t.Parallel()
		for _, test := range fromStringTests {
			t.Run(test.str, func(t *testing.T) {
				t.Parallel()
				assertEqualNumber(t, FromString(test.str), test.number)
			})
		}
	})
}

func TestStringRoundtrip(t *testing.T) {
	t.Parallel()

	for _, test := range stringTests {
		t.Run(test.str, func(t *testing.T) {
			t.Parallel()
			assert.Equal(t, FromString(test.str).String(), test.str)
		})
	}
}

func TestStringJS(t *testing.T) {
	t.Parallel()
	jstest.SkipIfNoNodeJS(t)

	t.Run("stringTests", func(t *testing.T) {
		t.Parallel()

		// These tests should roundtrip both ways.
		stringTestsResults := getStringResultsFromJS(t, stringTests)
		for i, test := range stringTests {
			t.Run(fmt.Sprintf("%v", float64(test.number)), func(t *testing.T) {
				t.Parallel()
				assertEqualNumber(t, stringTestsResults[i].number, test.number)
				assert.Equal(t, stringTestsResults[i].str, test.str)
			})
		}
	})

	t.Run("fromStringTests", func(t *testing.T) {
		t.Parallel()

		// These tests should convert the string to the same number.
		fromStringTestsResults := getStringResultsFromJS(t, fromStringTests)
		for i, test := range fromStringTests {
			t.Run(fmt.Sprintf("fromString %q", test.str), func(t *testing.T) {
				t.Parallel()
				assertEqualNumber(t, fromStringTestsResults[i].number, test.number)
			})
		}
	})
}

func isFuzzing() bool {
	return flag.CommandLine.Lookup("test.fuzz").Value.String() != ""
}

func FuzzStringJS(f *testing.F) {
	jstest.SkipIfNoNodeJS(f)

	if isFuzzing() {
		// Avoid running anything other than regressions in the fuzzing mode.
		for _, test := range stringTests {
			f.Add(float64(test.number))
		}
		for _, test := range fromStringTests {
			f.Add(float64(test.number))
		}
	}

	f.Fuzz(func(t *testing.T, f float64) {
		n := Number(f)
		nStr := n.String()

		results := getStringResultsFromJS(t, []stringTest{{number: n, str: nStr}})
		assert.Equal(t, len(results), 1)

		nToJSStr := results[0].str
		nStrToJSNumber := results[0].number

		assert.Equal(t, nStr, nToJSStr)
		assertEqualNumber(t, n, nStrToJSNumber)
	})
}

func FuzzFromStringJS(f *testing.F) {
	jstest.SkipIfNoNodeJS(f)

	if isFuzzing() {
		// Avoid running anything other than regressions in the fuzzing mode.
		for _, test := range stringTests {
			f.Add(test.str)
		}
		for _, test := range fromStringTests {
			f.Add(test.str)
		}
	}

	f.Fuzz(func(t *testing.T, s string) {
		if len(s) > 350 {
			t.Skip()
		}

		n := FromString(s)
		results := getStringResultsFromJS(t, []stringTest{{str: s}})
		assert.Equal(t, len(results), 1)
		assertEqualNumber(t, n, results[0].number)
	})
}

func getStringResultsFromJS(t testing.TB, tests []stringTest) []stringTest {
	t.Helper()
	tmpdir := t.TempDir()

	type data struct {
		Bits [2]uint32 `json:"bits"`
		Str  string    `json:"str"`
	}

	inputData := make([]data, len(tests))
	for i, test := range tests {
		inputData[i] = data{
			Bits: numberToUint32Array(test.number),
			Str:  test.str,
		}
	}

	jsonInput, err := json.Marshal(inputData)
	assert.NilError(t, err)

	jsonInputPath := filepath.Join(tmpdir, "input.json")
	err = os.WriteFile(jsonInputPath, jsonInput, 0o644)
	assert.NilError(t, err)

	script := `
		import fs from 'fs';

		function fromBits(bits) {
			const buffer = new ArrayBuffer(8);
			(new Uint32Array(buffer))[0] = bits[0];
			(new Uint32Array(buffer))[1] = bits[1];
			return new Float64Array(buffer)[0];
		}

		function toBits(number) {
			const buffer = new ArrayBuffer(8);
			(new Float64Array(buffer))[0] = number;
			return [(new Uint32Array(buffer))[0], (new Uint32Array(buffer))[1]];
		}

		export default function(inputFile) {
			const input = JSON.parse(fs.readFileSync(inputFile, 'utf8'));

			const output = input.map((input) => ({
				str: ""+fromBits(input.bits),
				bits: toBits(+input.str),	
			}));

			return output;
		};
	`

	outputData, err := jstest.EvalNodeScript[[]data](t, script, tmpdir, jsonInputPath)
	assert.NilError(t, err)
	assert.Equal(t, len(outputData), len(tests))

	output := make([]stringTest, len(tests))
	for i, outputDatum := range outputData {
		output[i] = stringTest{
			number: uint32ArrayToNumber(outputDatum.Bits),
			str:    outputDatum.Str,
		}
	}

	return output
}

func numberToUint32Array(n Number) [2]uint32 {
	bits := numberToBits(n)
	return [2]uint32{uint32(bits), uint32(bits >> 32)}
}

func uint32ArrayToNumber(a [2]uint32) Number {
	bits := uint64(a[0]) | uint64(a[1])<<32
	return numberFromBits(bits)
}