package legacyreport

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	"galaxy/model/report"
)

// TestParseHeaderAndSize covers the standalone single-line preamble.
func TestParseHeaderAndSize(t *testing.T) {
	in := strings.Join([]string{
		"       KnightErrants Report for Galaxy PLUS dg283 Turn 39 Thu Jul 06 09:01:16 2000",
		"",
		"                    Size: 800  Planets: 700  Players: 91",
		"",
	}, "\n")

	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := rep.Race, "KnightErrants"; got != want {
		t.Errorf("Race = %q, want %q", got, want)
	}
	if got, want := rep.Turn, uint(39); got != want {
		t.Errorf("Turn = %d, want %d", got, want)
	}
	if got, want := rep.Width, uint32(800); got != want {
		t.Errorf("Width = %d, want %d", got, want)
	}
	if got, want := rep.Height, uint32(800); got != want {
		t.Errorf("Height = %d, want %d", got, want)
	}
	if got, want := rep.PlanetCount, uint32(700); got != want {
		t.Errorf("PlanetCount = %d, want %d", got, want)
	}
}

// TestParseStatusOfPlayers exercises the alive / extinct distinction
// that drives the races view.
func TestParseStatusOfPlayers(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Status of Players (total 10.00 votes)",
		"",
		"N             D     W     S     C       P       I  #  R     V",
		"Alpha      4.51  2.24  1.80  1.00  100.00   80.00  3  War   3.00",
		"Bravo      9.03  5.62  2.16  1.53  200.00  150.00  5  Peace 5.00",
		"Gone_RIP   1.00  1.00  1.00  1.00    0.00    0.00  0  War   0.00",
		"",
	}, "\n")

	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := len(rep.Player), 3; got != want {
		t.Fatalf("len(Player) = %d, want %d", got, want)
	}
	alpha := rep.Player[0]
	if alpha.Name != "Alpha" || alpha.Extinct {
		t.Errorf("Alpha = %+v, want Name=Alpha extinct=false", alpha)
	}
	if alpha.Planets != 3 || alpha.Relation != "War" {
		t.Errorf("Alpha planets/relation = %d/%q, want 3/War", alpha.Planets, alpha.Relation)
	}
	if got, want := float64(alpha.Drive), 4.51; got != want {
		t.Errorf("Alpha.Drive = %v, want %v", got, want)
	}
	gone := rep.Player[2]
	if gone.Name != "Gone" || !gone.Extinct {
		t.Errorf("Gone = %+v, want Name=Gone extinct=true (suffix _RIP stripped)", gone)
	}
}

func TestParseYourVote(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Your vote:",
		"",
		"R              V",
		"KnightErrants  16.02",
		"",
	}, "\n")
	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if rep.VoteFor != "KnightErrants" {
		t.Errorf("VoteFor = %q, want KnightErrants", rep.VoteFor)
	}
	if got, want := float64(rep.Votes), 16.02; got != want {
		t.Errorf("Votes = %v, want %v", got, want)
	}
}

func TestParseLocalAndOtherPlanets(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Your Planets",
		"",
		"  #       X       Y  N         S        P        I      R  P                $       M       C        L",
		" 17  171.05  700.24  Castle  1000.00  1000.00  1000.00  10.00  Drive_Research  0.00    0.68   88.78  1000.00",
		" 87  169.59  694.49  North    500.00   500.00   500.00  10.00  Capital         0.00    0.52   35.76   500.00",
		"",
		"Monstrai Planets",
		"",
		"  #       X       Y  N             S       P       I      R  P              $       M      C       L",
		" 12  303.84  579.23  Skarabei  500.00  500.00  500.00  10.00  Capital     0.00   70.99  20.03  341.78",
		"",
	}, "\n")
	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := len(rep.LocalPlanet), 2; got != want {
		t.Fatalf("len(LocalPlanet) = %d, want %d", got, want)
	}
	castle := rep.LocalPlanet[0]
	if castle.Number != 17 || castle.Name != "Castle" {
		t.Errorf("Castle = (%d, %q), want (17, Castle)", castle.Number, castle.Name)
	}
	if castle.Production != "Drive_Research" {
		t.Errorf("Castle.Production = %q, want Drive_Research", castle.Production)
	}
	if got, want := float64(castle.Size), 1000.0; got != want {
		t.Errorf("Castle.Size = %v, want %v", got, want)
	}
	if got, want := len(rep.OtherPlanet), 1; got != want {
		t.Fatalf("len(OtherPlanet) = %d, want %d", got, want)
	}
	skarabei := rep.OtherPlanet[0]
	if skarabei.Owner != "Monstrai" {
		t.Errorf("Skarabei.Owner = %q, want Monstrai", skarabei.Owner)
	}
	if skarabei.Number != 12 || skarabei.Name != "Skarabei" {
		t.Errorf("Skarabei = (%d, %q), want (12, Skarabei)", skarabei.Number, skarabei.Name)
	}
}

func TestParseUninhabitedAndUnidentified(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Uninhabited Planets",
		"",
		"  #       X       Y  N            S      R     $        M",
		"  9  117.87  795.21  Dw2     500.00  10.00  0.00   500.00",
		"",
		"Unidentified Planets",
		"",
		"  #       X       Y",
		"  0  738.08  600.26",
		"  1  579.12  489.37",
		"",
	}, "\n")
	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := len(rep.UninhabitedPlanet), 1; got != want {
		t.Fatalf("len(UninhabitedPlanet) = %d, want %d", got, want)
	}
	dw2 := rep.UninhabitedPlanet[0]
	if dw2.Number != 9 || dw2.Name != "Dw2" {
		t.Errorf("Dw2 = (%d, %q), want (9, Dw2)", dw2.Number, dw2.Name)
	}
	if got, want := len(rep.UnidentifiedPlanet), 2; got != want {
		t.Fatalf("len(UnidentifiedPlanet) = %d, want %d", got, want)
	}
	first := rep.UnidentifiedPlanet[0]
	if first.Number != 0 || float64(first.X) != 738.08 || float64(first.Y) != 600.26 {
		t.Errorf("Unidentified[0] = %+v, want (0, 738.08, 600.26)", first)
	}
}

func TestParseShipClasses(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Your Ship Types",
		"",
		"N             D    A      W      S      C       M",
		"Frontier  11.37    0   0.00   0.00   1.00   12.37",
		"Bow105    74.77  105   1.00  19.72   1.00  148.49",
		"",
		"Monstrai Ship Types",
		"",
		"N         D    A      W      S  C       M",
		"Dragon  16.70   1   1.10   1.00  1   19.80",
		"",
	}, "\n")
	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := len(rep.LocalShipClass), 2; got != want {
		t.Fatalf("len(LocalShipClass) = %d, want %d (foreign types must be ignored)", got, want)
	}
	bow := rep.LocalShipClass[1]
	if bow.Name != "Bow105" || bow.Armament != 105 {
		t.Errorf("Bow105 name/armament = %q/%d, want Bow105/105", bow.Name, bow.Armament)
	}
	if got, want := float64(bow.Drive), 74.77; got != want {
		t.Errorf("Bow105.Drive = %v, want %v", got, want)
	}
}

func TestParseSkipsBattlesAndBombings(t *testing.T) {
	in := strings.Join([]string{
		"Race Report for Galaxy PLUS Turn 1",
		"",
		"Battle at (#7) B-007",
		"",
		"#  T          D  W  S  C  T  Q  L",
		"1  PeaceShip  4  0  0  0  -  0  1  Out_Battle",
		"",
		"Battle Protocol",
		"",
		"Foo fires on Bar : Destroyed",
		"",
		"Bombings",
		"",
		"# data line",
		"",
		"Your Planets",
		"",
		"  #       X       Y  N         S        P        I      R  P              $       M       C        L",
		" 17  171.05  700.24  Castle  1000.00  1000.00  1000.00  10.00  Capital  0.00    0.68   88.78  1000.00",
		"",
	}, "\n")
	rep, err := Parse(strings.NewReader(in))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if got, want := len(rep.LocalPlanet), 1; got != want {
		t.Fatalf("len(LocalPlanet) = %d, want %d (battle/bombing rows must not leak in)", got, want)
	}
}

// TestParseDgKNNTS039 is a smoke test: the parser must produce
// stable top-line counts from the real dg/KNNTS039.REP fixture.
// Field-level fidelity is asserted in the unit tests above; this
// test catches regressions where a section-classifier change
// silently drops half the data.
func TestParseDgKNNTS039(t *testing.T) {
	const path = "../reports/dg/KNNTS039.REP"
	rep, err := parseFile(t, path)
	if err != nil {
		if os.IsNotExist(err) {
			t.Skipf("legacy report fixture missing: %s", path)
		}
		t.Fatalf("Parse %s: %v", path, err)
	}
	want := struct {
		race                                                                   string
		turn                                                                   uint
		mapW, mapH, planetCount                                                uint32
		voteFor                                                                string
		votes                                                                  float64
		players, extinct, local, other, uninhabited, unidentified, shipClasses int
	}{
		race: "KnightErrants", turn: 39,
		mapW: 800, mapH: 800, planetCount: 700,
		voteFor: "KnightErrants", votes: 16.02,
		players: 91, extinct: 49,
		local: 22, other: 89, uninhabited: 17, unidentified: 572,
		shipClasses: 24,
	}
	if rep.Race != want.race || rep.Turn != want.turn {
		t.Errorf("(race, turn) = (%q, %d), want (%q, %d)", rep.Race, rep.Turn, want.race, want.turn)
	}
	if rep.Width != want.mapW || rep.Height != want.mapH || rep.PlanetCount != want.planetCount {
		t.Errorf("(W, H, planets) = (%d, %d, %d), want (%d, %d, %d)",
			rep.Width, rep.Height, rep.PlanetCount, want.mapW, want.mapH, want.planetCount)
	}
	if rep.VoteFor != want.voteFor || float64(rep.Votes) != want.votes {
		t.Errorf("(voteFor, votes) = (%q, %v), want (%q, %v)",
			rep.VoteFor, float64(rep.Votes), want.voteFor, want.votes)
	}
	extinct := 0
	for _, pl := range rep.Player {
		if pl.Extinct {
			extinct++
		}
	}
	if got, exp := len(rep.Player), want.players; got != exp {
		t.Errorf("len(Player) = %d, want %d", got, exp)
	}
	if extinct != want.extinct {
		t.Errorf("extinct = %d, want %d", extinct, want.extinct)
	}
	if got, exp := len(rep.LocalPlanet), want.local; got != exp {
		t.Errorf("len(LocalPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.OtherPlanet), want.other; got != exp {
		t.Errorf("len(OtherPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.UninhabitedPlanet), want.uninhabited; got != exp {
		t.Errorf("len(UninhabitedPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.UnidentifiedPlanet), want.unidentified; got != exp {
		t.Errorf("len(UnidentifiedPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.LocalShipClass), want.shipClasses; got != exp {
		t.Errorf("len(LocalShipClass) = %d, want %d", got, exp)
	}
}

// TestParseGplus40 mirrors TestParseDgKNNTS039 for the gplus engine
// fixture so the variant difference (tabs vs spaces in headers) is
// exercised on a real file.
func TestParseGplus40(t *testing.T) {
	const path = "../reports/gplus/40.REP"
	rep, err := parseFile(t, path)
	if err != nil {
		if os.IsNotExist(err) {
			t.Skipf("legacy report fixture missing: %s", path)
		}
		t.Fatalf("Parse %s: %v", path, err)
	}
	want := struct {
		race                                                                   string
		turn                                                                   uint
		mapW, mapH, planetCount                                                uint32
		players, extinct, local, other, uninhabited, unidentified, shipClasses int
	}{
		race: "MbI", turn: 40,
		mapW: 350, mapH: 350, planetCount: 300,
		players: 26, extinct: 0,
		local: 26, other: 116, uninhabited: 7, unidentified: 152,
		shipClasses: 56,
	}
	if rep.Race != want.race || rep.Turn != want.turn {
		t.Errorf("(race, turn) = (%q, %d), want (%q, %d)", rep.Race, rep.Turn, want.race, want.turn)
	}
	if rep.Width != want.mapW || rep.Height != want.mapH || rep.PlanetCount != want.planetCount {
		t.Errorf("(W, H, planets) = (%d, %d, %d), want (%d, %d, %d)",
			rep.Width, rep.Height, rep.PlanetCount, want.mapW, want.mapH, want.planetCount)
	}
	extinct := 0
	for _, pl := range rep.Player {
		if pl.Extinct {
			extinct++
		}
	}
	if got, exp := len(rep.Player), want.players; got != exp {
		t.Errorf("len(Player) = %d, want %d", got, exp)
	}
	if extinct != want.extinct {
		t.Errorf("extinct = %d, want %d", extinct, want.extinct)
	}
	if got, exp := len(rep.LocalPlanet), want.local; got != exp {
		t.Errorf("len(LocalPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.OtherPlanet), want.other; got != exp {
		t.Errorf("len(OtherPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.UninhabitedPlanet), want.uninhabited; got != exp {
		t.Errorf("len(UninhabitedPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.UnidentifiedPlanet), want.unidentified; got != exp {
		t.Errorf("len(UnidentifiedPlanet) = %d, want %d", got, exp)
	}
	if got, exp := len(rep.LocalShipClass), want.shipClasses; got != exp {
		t.Errorf("len(LocalShipClass) = %d, want %d", got, exp)
	}
}

func parseFile(t *testing.T, rel string) (report.Report, error) {
	t.Helper()
	abs, err := filepath.Abs(rel)
	if err != nil {
		return report.Report{}, err
	}
	f, err := os.Open(abs)
	if err != nil {
		return report.Report{}, err
	}
	defer func() { _ = f.Close() }()
	return Parse(f)
}