// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
// SPDX-License-Identifier: MIT

package optim

import (
	"math"
	"strings"
	"testing"

	"sourcedock.dev/petrbalvin/tensor/internal/core"
)

// TestLUFactorSolve pins the shared factorisation machinery on a
// non-symmetric matrix: both triangle directions are load-bearing,
// solve for the primal ratios and solveT for the dual prices and the
// redundant-row scan.
func TestLUFactorSolve(t *testing.T) {
	// A = [[2, 1], [4, 3]], det = 2: A(1, 3) = (5, 13) and
	// Aᵀ(2, 1) = (8, 5).
	f, err := factorLU([]float64{2, 1, 4, 3}, 2)
	if err != nil {
		t.Fatalf("factorLU: %v", err)
	}
	x := make([]float64, 2)
	f.solve([]float64{5, 13}, x)
	if math.Abs(x[0]-1) > 1e-12 || math.Abs(x[1]-3) > 1e-12 {
		t.Fatalf("solve = (%g, %g), want (1, 3)", x[0], x[1])
	}
	f.solveT([]float64{8, 5}, x)
	if math.Abs(x[0]-2) > 1e-12 || math.Abs(x[1]-1) > 1e-12 {
		t.Fatalf("solveT = (%g, %g), want (2, 1)", x[0], x[1])
	}
	// A singular matrix is refused, not divided through.
	if _, err := factorLU([]float64{1, 2, 2, 4}, 2); err == nil {
		t.Fatal("a singular matrix was factored")
	}
	// So is a zero matrix, named as such rather than a pivot.
	if _, err := factorLU(make([]float64, 4), 2); err == nil {
		t.Fatal("a zero matrix was factored")
	}
	if _, err := factorLU(nil, 0); err != nil {
		t.Fatalf("a zero-sized factorisation was refused: %v", err)
	}
}

// TestMinimiseLinearStandardVertex pins a hand-built optimum at a
// known vertex: min −(2x + 3y) over x + y ≤ 4, 2x + y ≤ 6 with the
// slacks carried explicitly. The vertices price out at 0, 6, 10 and
// 12, so the answer is the vertex (0, 4, 0, 2) with value −12.
func TestMinimiseLinearStandardVertex(t *testing.T) {
	c := mustFloats(t, []float64{-2, -3, 0, 0})
	a := mustFloats(t, []float64{1, 1, 1, 0, 2, 1, 0, 1}, 2, 4)
	b := mustFloats(t, []float64{4, 6})
	x, value, err := MinimiseLinear(c, a, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear: %v", err)
	}
	want := []float64{0, 4, 0, 2}
	for i, w := range want {
		if math.Abs(x.FloatAt(i)-w) > 1e-9 {
			t.Fatalf("x[%d] = %.12g, want %g", i, x.FloatAt(i), w)
		}
	}
	if math.Abs(value+12) > 1e-9 {
		t.Fatalf("value = %.12g, want −12", value)
	}
}

// TestMinimiseLinearRowsVertex drives the two-sided wrapper over the
// same polytope expressed as house rows with free variables: max
// x + 2y on x + y ≤ 4, x + 3y ≤ 6, x, y ≥ 0. The vertex prices are 0,
// 4, 5 and 4, so the optimum is the vertex (3, 1) with value 5.
func TestMinimiseLinearRowsVertex(t *testing.T) {
	c := mustFloats(t, []float64{-1, -2})
	cons := LinearConstraints{
		A:     mustFloats(t, []float64{1, 1, 1, 3, 1, 0, 0, 1}, 4, 2),
		Lower: []float64{math.Inf(-1), math.Inf(-1), 0, 0},
		Upper: []float64{4, 6, math.Inf(1), math.Inf(1)},
	}
	x, value, err := MinimiseLinearRows(c, cons, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinearRows: %v", err)
	}
	if math.Abs(x.FloatAt(0)-3) > 1e-9 || math.Abs(x.FloatAt(1)-1) > 1e-9 {
		t.Fatalf("x = (%.12g, %.12g), want the vertex (3, 1)", x.FloatAt(0), x.FloatAt(1))
	}
	if math.Abs(value+5) > 1e-9 {
		t.Fatalf("value = %.12g, want −5", value)
	}
}

// TestMinimiseLinearNegativeRightHandSide pins the row negation: a
// standard-form row arrives with b < 0 and must come out of the
// artificial phase feasible all the same.
func TestMinimiseLinearNegativeRightHandSide(t *testing.T) {
	c := mustFloats(t, []float64{1, 1})
	a := mustFloats(t, []float64{-1, -1}, 1, 2)
	b := mustFloats(t, []float64{-2})
	x, value, err := MinimiseLinear(c, a, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear: %v", err)
	}
	if math.Abs(value-2) > 1e-9 {
		t.Fatalf("value = %.12g, want 2", value)
	}
	if math.Abs(x.FloatAt(0)+x.FloatAt(1)-2) > 1e-9 {
		t.Fatalf("x + y = %.12g, want 2", x.FloatAt(0)+x.FloatAt(1))
	}
}

// TestMinimiseLinearBudget pins the pivot-budget refusal: one pivot
// cannot carry the vertex problem to its optimum, and an exhausted
// budget is an error, never a silent answer.
func TestMinimiseLinearBudget(t *testing.T) {
	c := mustFloats(t, []float64{-2, -3, 0, 0})
	a := mustFloats(t, []float64{1, 1, 1, 0, 2, 1, 0, 1}, 2, 4)
	b := mustFloats(t, []float64{4, 6})
	_, _, err := MinimiseLinear(c, a, b, LinearProgramOptions{MaxIterations: 1})
	if err == nil || !strings.Contains(err.Error(), "budget") {
		t.Fatalf("error = %v, want the pivot-budget refusal", err)
	}
}

// TestMinimiseLinearDegenerateTerminates pins the anti-cycling
// guarantee where it earns its keep: two identical equality rows plus
// a third at twice the scale leave the problem degenerate and
// redundant at once, the classic rules can pivot forever on such a
// vertex, and Bland's rule must terminate, dropping the redundant rows
// and their artificials, with a point on the feasible segment.
func TestMinimiseLinearDegenerateTerminates(t *testing.T) {
	c := mustFloats(t, []float64{-1, -1})
	cons := LinearConstraints{
		A:     mustFloats(t, []float64{1, 1, 1, 1, 2, 2}, 3, 2),
		Lower: []float64{1, 1, 2},
		Upper: []float64{1, 1, 2},
	}
	x, value, err := MinimiseLinearRows(c, cons, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinearRows on a degenerate problem: %v", err)
	}
	if math.Abs(value+1) > 1e-9 {
		t.Fatalf("value = %.12g, want −1", value)
	}
	if x.FloatAt(0) < -1e-9 || x.FloatAt(1) < -1e-9 {
		t.Fatalf("x = (%g, %g) left the non-negative quadrant", x.FloatAt(0), x.FloatAt(1))
	}
	if math.Abs(x.FloatAt(0)+x.FloatAt(1)-1) > 1e-9 {
		t.Fatalf("x + y = %.12g, want 1", x.FloatAt(0)+x.FloatAt(1))
	}
}

// TestMinimiseLinearDegenerateOrigin pins the other degenerate shape:
// a zero right-hand side keeps the artificials basic at the phase-1
// optimum, so the phase transition must pivot them out with degenerate
// steps before phase 2. The feasible set of x + y = 0, x − y = 0 over
// x, y ≥ 0 is the origin alone.
func TestMinimiseLinearDegenerateOrigin(t *testing.T) {
	c := mustFloats(t, []float64{-1, -1})
	a := mustFloats(t, []float64{1, 1, 1, -1}, 2, 2)
	b := mustFloats(t, []float64{0, 0})
	x, value, err := MinimiseLinear(c, a, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear: %v", err)
	}
	if value != 0 {
		t.Fatalf("value = %g, want 0", value)
	}
	for i := range 2 {
		if x.FloatAt(i) != 0 {
			t.Fatalf("x[%d] = %g, want 0", i, x.FloatAt(i))
		}
	}
}

// TestMinimiseLinearBeale pins Beale's cycling example, the classic
// demonstration that Dantzig's rule can pivot forever (Beale, 1955;
// the form in Chvátal's Linear Programming, chapter 3). The optimum is
// 0.05 at (1/25, 0, 1, 0) with the first slack carrying the 0.03 the
// first row leaves loose, so minimising the negated objective returns
// −0.05 there.
func TestMinimiseLinearBeale(t *testing.T) {
	c := mustFloats(t, []float64{-0.75, 150, -0.02, 6, 0, 0, 0})
	a := mustFloats(t, []float64{
		0.25, -60, -0.04, 9, 1, 0, 0,
		0.5, -90, -0.02, 3, 0, 1, 0,
		0, 0, 1, 0, 0, 0, 1,
	}, 3, 7)
	b := mustFloats(t, []float64{0, 0, 1})
	x, value, err := MinimiseLinear(c, a, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear on Beale's example: %v", err)
	}
	want := []float64{1.0 / 25.0, 0, 1, 0, 0.03, 0, 0}
	for i, w := range want {
		if math.Abs(x.FloatAt(i)-w) > 1e-9 {
			t.Fatalf("x[%d] = %.12g, want %.12g", i, x.FloatAt(i), w)
		}
	}
	if math.Abs(value+0.05) > 1e-9 {
		t.Fatalf("value = %.12g, want −0.05", value)
	}
}

// TestMinimiseLinearInfeasible pins the phase-1 refusal: x ≥ 1 and
// x ≤ 0 share no feasible point, and the error must carry the
// infeasibility the artificial phase ended with.
func TestMinimiseLinearInfeasible(t *testing.T) {
	c := mustFloats(t, []float64{1})
	cons := LinearConstraints{
		A:     mustFloats(t, []float64{1, 1}, 2, 1),
		Lower: []float64{math.Inf(-1), 1},
		Upper: []float64{0, math.Inf(1)},
	}
	_, _, err := MinimiseLinearRows(c, cons, LinearProgramOptions{})
	if err == nil {
		t.Fatal("an infeasible problem returned a solution")
	}
	if !strings.Contains(err.Error(), "infeasible") {
		t.Fatalf("error = %v, want the phase-1 infeasibility evidence", err)
	}
	// The named row must be the one that carries the worst figure, not
	// whichever artificial the scan touched after row 1: two empty rows
	// leave their artificials at 1 and 0.5, and the zero-initialised
	// worst-row sentinel once let the smaller overwrite the evidence.
	_, _, err = MinimiseLinear(mustFloats(t, []float64{0}),
		mustFloats(t, []float64{0, 0}, 2, 1), mustFloats(t, []float64{1, 0.5}, 2), LinearProgramOptions{})
	if err == nil || !strings.Contains(err.Error(), "row 1 still carries 1") {
		t.Fatalf("worst row misreported: %v", err)
	}
}

// TestMinimiseLinearUnbounded pins the ray refusal in both entries.
func TestMinimiseLinearUnbounded(t *testing.T) {
	// Standard form: x = y with min −x runs along the ray (t, t).
	_, _, err := MinimiseLinear(mustFloats(t, []float64{-1, 0}),
		mustFloats(t, []float64{1, -1}, 1, 2), mustFloats(t, []float64{0}), LinearProgramOptions{})
	if err == nil || !strings.Contains(err.Error(), "unbounded") {
		t.Fatalf("standard form: error = %v, want an unbounded refusal", err)
	}
	// Rows: x ≥ 0 with min −x.
	_, _, err = MinimiseLinearRows(mustFloats(t, []float64{-1}),
		LinearConstraints{A: mustFloats(t, []float64{1}, 1, 1),
			Lower: []float64{0}, Upper: []float64{math.Inf(1)}}, LinearProgramOptions{})
	if err == nil || !strings.Contains(err.Error(), "unbounded") {
		t.Fatalf("rows: error = %v, want an unbounded refusal", err)
	}
}

// TestMinimiseLinearNoRows pins the row-free standard form: over x ≥ 0
// alone a non-negative cost bottoms out at the origin and a negative
// cost is unbounded.
func TestMinimiseLinearNoRows(t *testing.T) {
	x, value, err := MinimiseLinear(mustFloats(t, []float64{1, 2}), core.New(core.Float, 0, 2),
		core.New(core.Float, 0), LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear: %v", err)
	}
	if value != 0 {
		t.Fatalf("value = %g, want 0", value)
	}
	for i := range 2 {
		if x.FloatAt(i) != 0 {
			t.Fatalf("x[%d] = %g, want 0", i, x.FloatAt(i))
		}
	}
	if _, _, err := MinimiseLinear(mustFloats(t, []float64{-1, 2}), core.New(core.Float, 0, 2),
		core.New(core.Float, 0), LinearProgramOptions{}); err == nil {
		t.Fatal("a negative cost without rows was not refused as unbounded")
	}
}

// TestMinimiseLinearRefusals checks every input gate of both entries.
func TestMinimiseLinearRefusals(t *testing.T) {
	empty := core.New(core.Float, 0)
	c2 := mustFloats(t, []float64{1, 2})
	a22 := mustFloats(t, []float64{1, 1, 0, 1}, 2, 2)
	b2 := mustFloats(t, []float64{1, 1})
	cases := []struct {
		name string
		run  func() error
	}{
		{"empty cost", func() error {
			_, _, err := MinimiseLinear(empty, a22, b2, LinearProgramOptions{})
			return err
		}},
		{"complex cost", func() error {
			_, _, err := MinimiseLinear(mustComplexPoint(t), a22, b2, LinearProgramOptions{})
			return err
		}},
		{"nil matrix", func() error {
			_, _, err := MinimiseLinear(c2, nil, b2, LinearProgramOptions{})
			return err
		}},
		{"matrix shape", func() error {
			_, _, err := MinimiseLinear(c2, mustFloats(t, []float64{1, 1}), b2, LinearProgramOptions{})
			return err
		}},
		{"right-hand side length", func() error {
			_, _, err := MinimiseLinear(c2, a22, mustFloats(t, []float64{1}), LinearProgramOptions{})
			return err
		}},
		{"NaN coefficient", func() error {
			_, _, err := MinimiseLinear(c2, mustFloats(t, []float64{math.NaN(), 1, 0, 1}, 2, 2), b2, LinearProgramOptions{})
			return err
		}},
		{"NaN cost", func() error {
			_, _, err := MinimiseLinear(mustFloats(t, []float64{math.NaN(), 1}), a22, b2, LinearProgramOptions{})
			return err
		}},
		{"complex constraint matrix", func() error {
			ca, _ := core.FromComplexes([]complex128{1, 0, 0, 1}, 2, 2)
			_, _, err := MinimiseLinear(c2, ca, b2, LinearProgramOptions{})
			return err
		}},
		{"complex right-hand side", func() error {
			cb, _ := core.FromComplexes([]complex128{1, 1}, 2)
			_, _, err := MinimiseLinear(c2, a22, cb, LinearProgramOptions{})
			return err
		}},
		{"NaN right-hand side", func() error {
			_, _, err := MinimiseLinear(c2, a22, mustFloats(t, []float64{math.NaN(), 1}), LinearProgramOptions{})
			return err
		}},
	}
	for _, c := range cases {
		if err := c.run(); err == nil {
			t.Fatalf("MinimiseLinear: %s accepted", c.name)
		}
	}
	rows := []struct {
		name string
		cons LinearConstraints
	}{
		{"nil matrix", LinearConstraints{Lower: []float64{0}, Upper: []float64{1}}},
		{"matrix shape", LinearConstraints{A: mustFloats(t, []float64{1, 1}), Lower: []float64{0}, Upper: []float64{1}}},
		{"no rows", LinearConstraints{A: core.New(core.Float, 0, 2), Lower: nil, Upper: nil}},
		{"short bounds", LinearConstraints{A: a22, Lower: []float64{0}, Upper: []float64{}}},
		{"crossed bounds", LinearConstraints{A: a22, Lower: []float64{1, 0}, Upper: []float64{0, 1}}},
		{"equality at infinity", LinearConstraints{A: a22,
			Lower: []float64{math.Inf(1), 0}, Upper: []float64{math.Inf(1), 1}}},
		{"NaN bound", LinearConstraints{A: a22, Lower: []float64{math.NaN(), 0}, Upper: []float64{1, 1}}},
		{"NaN coefficient", LinearConstraints{A: mustFloats(t, []float64{math.NaN(), 1, 0, 1}, 2, 2),
			Lower: []float64{0, 0}, Upper: []float64{1, 1}}},
	}
	for _, r := range rows {
		if _, _, err := MinimiseLinearRows(c2, r.cons, LinearProgramOptions{}); err == nil {
			t.Fatalf("MinimiseLinearRows: %s accepted", r.name)
		}
	}
	// The rows entry's own cost gates.
	rowCosts := []struct {
		name string
		c    *core.Array
	}{
		{"empty cost", core.New(core.Float, 0)},
		{"complex cost", mustComplexPoint(t)},
		{"NaN cost", mustFloats(t, []float64{math.NaN(), 1})},
	}
	for _, rc := range rowCosts {
		if _, _, err := MinimiseLinearRows(rc.c, LinearConstraints{A: a22, Lower: []float64{0, 0}, Upper: []float64{1, 1}},
			LinearProgramOptions{}); err == nil {
			t.Fatalf("MinimiseLinearRows: %s accepted", rc.name)
		}
	}
	// Complex constraint matrices are refused here too.
	ca, _ := core.FromComplexes([]complex128{1, 0, 0, 1}, 2, 2)
	if _, _, err := MinimiseLinearRows(c2, LinearConstraints{A: ca, Lower: []float64{0, 0}, Upper: []float64{1, 1}},
		LinearProgramOptions{}); err == nil {
		t.Fatal("MinimiseLinearRows: a complex constraint matrix was accepted")
	}
}

// TestMinimiseLinearRowsNegativeBounds pins the negation of a
// right-hand side the artificial basis needs: a two-sided model whose
// bound rows come out negative (a lower bound below zero, a bare
// negative equality) builds standard rows with b >= 0 and solves,
// where an unnegated row lost primal feasibility at pivot 0.
func TestMinimiseLinearRowsNegativeBounds(t *testing.T) {
	a, err := core.FromFloats([]float64{1, 0, 0, 1}, 2, 2)
	if err != nil {
		t.Fatal(err)
	}
	cons := LinearConstraints{
		A:     a,
		Lower: []float64{-1, 2},
		Upper: []float64{math.Inf(1), math.Inf(1)},
	}
	x, v, err := MinimiseLinearRows(mustFloats(t, []float64{1, 1}), cons, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("negative lower bound refused: %v", err)
	}
	if v != 1 || x.FloatAt(0) != -1 || x.FloatAt(1) != 2 {
		t.Fatalf("x = (%g, %g) value %g, want (-1, 2) at 1", x.FloatAt(0), x.FloatAt(1), v)
	}
	// The bare negative equality rides the same negation through the
	// QP entry's feasibility path.
	h, herr := core.FromFloats([]float64{2, 0, 0, 2}, 2, 2)
	if herr != nil {
		t.Fatal(herr)
	}
	eq, eerr := core.FromFloats([]float64{1, 1}, 1, 2)
	if eerr != nil {
		t.Fatal(eerr)
	}
	eqCons := LinearConstraints{A: eq, Lower: []float64{-1}, Upper: []float64{-1}}
	q, qv, _, qerr := MinimiseQP(h, mustFloats(t, []float64{4, 0}), eqCons, nil, QPOptions{})
	if qerr != nil {
		t.Fatalf("negative equality refused: %v", qerr)
	}
	if math.Abs(q.FloatAt(0)-(-1.5)) > 1e-9 || math.Abs(q.FloatAt(1)-0.5) > 1e-9 || math.Abs(qv+3.5) > 1e-9 {
		t.Fatalf("x = (%g, %g) value %g, want (-1.5, 0.5) at -3.5", q.FloatAt(0), q.FloatAt(1), qv)
	}
}

// TestMinimiseLinearExpelsTwoArtificials pins the reused unit vector in
// the artificial expulsion. The two rows below are exact negatives, so
// the phase-1 reduced costs cancel for every column: the artificial
// phase ends with both artificials still basic at zero and the
// expulsion runs twice, the second round reading a freshly cleared unit
// vector. A stale one scores the columns through the sum of two rows of
// B⁻¹ and swaps in a column that leaves the basis singular, so a solve
// that must answer the origin fails instead.
func TestMinimiseLinearExpelsTwoArtificials(t *testing.T) {
	a := mustFloats(t, []float64{1, 2, -1, -2}, 2, 2)
	b := mustFloats(t, []float64{0, 0})
	c := mustFloats(t, []float64{1, 1})
	x, value, err := MinimiseLinear(c, a, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear: %v", err)
	}
	if value != 0 {
		t.Fatalf("value = %.12g, want 0", value)
	}
	for i := range x.Len() {
		if x.FloatAt(i) != 0 {
			t.Fatalf("x[%d] = %.12g, want 0", i, x.FloatAt(i))
		}
	}
	// The same two-round expulsion over a scaled right-hand side: the
	// origin is the only feasible point whatever the rows' scale.
	scaled := mustFloats(t, []float64{3, 6, -3, -6}, 2, 2)
	x, value, err = MinimiseLinear(c, scaled, b, LinearProgramOptions{})
	if err != nil {
		t.Fatalf("MinimiseLinear over the scaled rows: %v", err)
	}
	if value != 0 || x.FloatAt(0) != 0 || x.FloatAt(1) != 0 {
		t.Fatalf("scaled rows: x = (%g, %g), value %g, want the origin", x.FloatAt(0), x.FloatAt(1), value)
	}
}