package calc_test

import (
	"errors"
	"strings"
	"testing"
	"time"

	"sneak.berlin/go/simplexcalc/internal/calc"
)

// TestEvaluate covers the two examples the bot was specified with, and
// the arithmetic around them.
func TestEvaluate(t *testing.T) {
	t.Parallel()

	expectResults(t, map[string]string{
		// The specification's own examples.
		"2 + 2":   "4",
		"5 * 5/2": "12.5",

		"2+2":          "4",
		"  7 - 10  \n": "-3",
		"-3 * 2":       "-6",
		"+4":           "4",
		"-(-4)":        "4",
		"(1 + 2) * 3":  "9",
		"1 + 2 * 3":    "7",
		"((2))":        "2",
		"8 / 2 / 2":    "2",
		"10 - 2 - 3":   "5",
		"7 / 2":        "3.5",
		"25/2":         "12.5",
		"1 / 3":        "0.3333333333333333",
		"2 / 3":        "0.6666666666666666",
		"0.1 + 0.2":    "0.3",
		"1.5 * 2":      "3",
		"2.50 * 2":     "5",
		".5 + .5":      "1",
		"3. * 2":       "6",
		"1e3 + 1":      "1001",
		"2.5e-1":       "0.25",
		"010 + 1":      "11",
		"-0":           "0",
		"0 / 5":        "0",
		// Exact: a float64 would print 99999999980000000000.
		"9999999999 * 9999999999": "99999999980000000001",
		"1e21":                    "1e+21",
		"1e20":                    "100000000000000000000",
		"1 / 1e7":                 "1e-07",
		"1 / 1e6":                 "0.000001",
		"1234567.5":               "1234567.5",
		"-1 / 4":                  "-0.25",
		"1e300 * 1e8":             "1e+308",
	})
}

// TestEvaluatePowers: ^ and ** are one operator, binding tighter than
// * / % and a sign on its left, and grouping to the right.
func TestEvaluatePowers(t *testing.T) {
	t.Parallel()

	expectResults(t, map[string]string{
		"2^3":               "8",
		"2**3":              "8",
		"2 ** 3 ^ 2":        "512",
		"2^3^2":             "512",
		"(2^3)^2":           "64",
		"-2^2":              "-4",
		"(-2)^2":            "4",
		"(-2)^3":            "-8",
		"(-2)^-3":           "-0.125",
		"2^-1":              "0.5",
		"2**-1":             "0.5",
		"-2^-2":             "-0.25",
		"2^-3^2":            "0.001953125",
		"2 * 3^2":           "18",
		"3^2 * 2":           "18",
		"2^3 / 2^2":         "2",
		"1 + 2^3 - 3^2":     "0",
		"010^2":             "100",
		"0.1^2":             "0.01",
		"2^100 - 2^100 + 1": "1",
		"2^64":              "18446744073709551616",
		"0^0":               "1",
		"0^3":               "0",
		"1.5^2":             "2.25",
		"2^0.5":             "1.4142135623730951",
		"-2^0.5":            "-1.4142135623730951",
		"4^0.5":             "2",
		"0^0.5":             "0",
		"2^1023":            "8.98846567431158e+307",
		// Past 2^53 a float64 cannot tell odd from even.
		"(-1)^(2^53 + 1)": "-1",
		"(-1)^(10^30)":    "1",
	})
}

// TestEvaluateModulo: % sits with * and /, left to right, and its result
// takes the sign of the divisor.
func TestEvaluateModulo(t *testing.T) {
	t.Parallel()

	expectResults(t, map[string]string{
		"7 % 3":       "1",
		"-7 % 3":      "2",
		"7 % -3":      "-2",
		"-7 % -3":     "-1",
		"6 % 3":       "0",
		"-6 % 3":      "0",
		"7.5 % 2":     "1.5",
		"0.3 % 0.1":   "0",
		"-0.3 % 0.2":  "0.1",
		"10 % 4 * 3":  "6",
		"2 * 7 % 4":   "2",
		"1 + 7 % 3":   "2",
		"2^10 % 7":    "2",
		"10^400 % 7":  "4",
		"1e-30 % 1":   "1e-30",
		"-1e-30 % 1":  "1",
		"10 / 8 % 1":  "0.25",
		"(7 % 3)^2":   "1",
		"7 % (3 ^ 2)": "7",
		// Both operands and their quotient are held exactly, but y times
		// the whole part of x/y is too large to be.
		"(5^860*3^630/7) % (5^860/2^998/2^998)": "0.5179219763783696",
	})
}

// expectResults checks that each expression evaluates to its result.
func expectResults(t *testing.T, cases map[string]string) {
	t.Helper()

	for in, want := range cases {
		t.Run(in, func(t *testing.T) {
			t.Parallel()

			got, err := calc.Evaluate(in)
			if err != nil {
				t.Fatalf("Evaluate(%q) failed: %v", in, err)
			}

			if got != want {
				t.Errorf("Evaluate(%q) = %q, want %q", in, got, want)
			}
		})
	}
}

// TestEvaluateRefuses covers what must be answered with an error rather
// than a number, and never with a panic.
func TestEvaluateRefuses(t *testing.T) {
	t.Parallel()

	cases := map[string]error{
		"":                          calc.ErrNotArithmetic,
		"   ":                       calc.ErrNotArithmetic,
		"hello":                     calc.ErrNotArithmetic,
		"/help":                     calc.ErrNotArithmetic,
		"2 +":                       calc.ErrNotArithmetic,
		"2 2":                       calc.ErrNotArithmetic,
		"2 + 2 =":                   calc.ErrNotArithmetic,
		"x + 1":                     calc.ErrNotArithmetic,
		"len(\"abc\")":              calc.ErrNotArithmetic,
		"\"a\" + \"b\"":             calc.ErrNotArithmetic,
		"'a' + 1":                   calc.ErrNotArithmetic,
		"2i * 2i":                   calc.ErrNotArithmetic,
		"0x10 + 1":                  calc.ErrNotArithmetic,
		"1_000 + 1":                 calc.ErrNotArithmetic,
		"1 << 10":                   calc.ErrNotArithmetic,
		"1 == 1":                    calc.ErrNotArithmetic,
		"!1":                        calc.ErrNotArithmetic,
		"func() int { return 1 }()": calc.ErrNotArithmetic,
		"(1 + 2":                    calc.ErrNotArithmetic,
		"1 + 2)":                    calc.ErrNotArithmetic,
		"()":                        calc.ErrNotArithmetic,
		"(2)(3)":                    calc.ErrNotArithmetic,
		"2 ^":                       calc.ErrNotArithmetic,
		"^ 2":                       calc.ErrNotArithmetic,
		"2 ^^ 3":                    calc.ErrNotArithmetic,
		"2 *** 3":                   calc.ErrNotArithmetic,
		"2 * * 3":                   calc.ErrNotArithmetic,
		"% 3":                       calc.ErrNotArithmetic,
		"50%":                       calc.ErrNotArithmetic,
		"2 × 3":                     calc.ErrNotArithmetic,
		"1 / 0":                     calc.ErrDivisionByZero,
		"1 / (2 - 2)":               calc.ErrDivisionByZero,
		"5 / 0.0":                   calc.ErrDivisionByZero,
		"7 % 0":                     calc.ErrDivisionByZero,
		"7.5 % (1 - 1)":             calc.ErrDivisionByZero,
		"0^-1":                      calc.ErrDivisionByZero,
		"0^-0.5":                    calc.ErrDivisionByZero,
		"(-2)^0.5":                  calc.ErrNoRealResult,
		"(-8)^(1/3)":                calc.ErrNoRealResult,
		"(-1)^-0.5":                 calc.ErrNoRealResult,
		"1e400":                     calc.ErrTooLarge,
		"1e300 * 1e300":             calc.ErrTooLarge,
		"1e999999999 * 1e999999999": calc.ErrTooLarge,
		"1 / 1e-400":                calc.ErrTooLarge,
		"2^1024":                    calc.ErrTooLarge,
		"2^5000":                    calc.ErrTooLarge,
		"(-2)^5001":                 calc.ErrTooLarge,
		"0.5^-5000":                 calc.ErrTooLarge,
		// go/constant holds numbers of this size rounded. A sum of them
		// can lose the answer (this one would be 0), and so can a
		// remainder or the sign of -1 to such a power.
		"7^1000 * 7^1000 + 5 - 7^1000 * 7^1000": calc.ErrTooLarge,
		"7^1000 * 7^1000 / 7^1000 % 10":         calc.ErrTooLarge,
		"(-1)^(3^1365 * 3^1365 / 3^1365)":       calc.ErrTooLarge,
		"(-1)^1e1300":                           calc.ErrTooLarge,
		"1e-1300":                               calc.ErrTooLarge,
		// Both operands are held exactly, but their quotient is not.
		"3^1365 % 7^-1000": calc.ErrTooLarge,
	}

	for in, want := range cases {
		t.Run(in, func(t *testing.T) {
			t.Parallel()

			got, err := calc.Evaluate(in)
			if !errors.Is(err, want) {
				t.Errorf("Evaluate(%q) = %q, %v; want error %v", in, got, err, want)
			}
		})
	}
}

// TestEvaluateBoundsWork: computed exactly, each of these powers would
// need more time and memory than any machine has. They must be answered
// at once.
func TestEvaluateBoundsWork(t *testing.T) {
	t.Parallel()

	cases := []struct {
		in   string
		want string
		err  error
	}{
		{in: "9^9^9^9^9", err: calc.ErrTooLarge},
		{in: "((9^999)^999)^999", err: calc.ErrTooLarge},
		{in: "1.0000001^99999", want: "1.01005006557947"},
		{in: "0.5^99999999999999999999", want: "0"},
		{in: "(-1)^99999999999999999999", want: "-1"},
		// The longest tower that fits.
		{in: strings.Repeat("9^", 127) + "9", err: calc.ErrTooLarge},
		// The largest power computed exactly, as often as fits.
		{in: "0" + strings.Repeat("*3^1365", 36), want: "0"},
	}

	for _, c := range cases {
		t.Run(c.in, func(t *testing.T) {
			t.Parallel()

			start := time.Now()
			got, err := calc.Evaluate(c.in)

			if elapsed := time.Since(start); elapsed > time.Second {
				t.Errorf("Evaluate(%q) took %v", c.in, elapsed)
			}

			if !errors.Is(err, c.err) || got != c.want {
				t.Errorf("Evaluate(%q) = %q, %v; want %q, %v", c.in, got, err, c.want, c.err)
			}
		})
	}
}

// TestEvaluateCapsInput: the length cap is what bounds the work a
// message can cause, so it must hold exactly at the boundary.
func TestEvaluateCapsInput(t *testing.T) {
	t.Parallel()

	// "1+1+...+1" with the last term padded to land exactly on the cap.
	longest := strings.Repeat("1+", calc.MaxInputLength/2-1) + "10"
	if len(longest) != calc.MaxInputLength {
		t.Fatalf("test setup: expression is %d bytes, want %d",
			len(longest), calc.MaxInputLength)
	}

	got, err := calc.Evaluate(longest)
	if err != nil {
		t.Fatalf("an expression of exactly MaxInputLength bytes was refused: %v", err)
	}

	if want := "137"; got != want {
		t.Errorf("Evaluate(longest) = %q, want %q", got, want)
	}

	_, err = calc.Evaluate(longest + "0")
	if !errors.Is(err, calc.ErrTooLong) {
		t.Errorf("an expression over MaxInputLength gave %v, want ErrTooLong", err)
	}

	// Surrounding whitespace is not part of the expression.
	_, err = calc.Evaluate("  " + longest + "\n")
	if err != nil {
		t.Errorf("whitespace around a maximal expression counted against the cap: %v", err)
	}
}