package game_test

import (
	"math/rand/v2"
	"testing"

	"github.com/google/uuid"
	"github.com/iliadenisov/galaxy/internal/model/game"
	"github.com/iliadenisov/galaxy/internal/number"
	"github.com/stretchr/testify/assert"
)

func TestCargoCapacity(t *testing.T) {
	test := func(cargoSize float64, expectCapacity float64) {
		ship := game.ShipType{
			ShipTypeReport: game.ShipTypeReport{
				Drive:    1,
				Armament: 1,
				Weapons:  1,
				Shields:  1,
				Cargo:    cargoSize,
			},
		}
		sg := game.ShipGroup{
			Number: 1,
			Tech: map[game.Tech]float64{
				game.TechDrive:   1.5,
				game.TechWeapons: 1.1,
				game.TechShields: 2.0,
				game.TechCargo:   1.0,
			},
		}
		assert.Equal(t, expectCapacity, sg.CargoCapacity(&ship))
	}
	test(1, 1.05)
	test(5, 6.25)
	test(10, 15)
	test(50, 175)
	test(100, 600)
}

func TestCarryingAndFullMass(t *testing.T) {
	Freighter := &game.ShipType{
		ShipTypeReport: game.ShipTypeReport{
			Name:     "Freighter",
			Drive:    8,
			Armament: 0,
			Weapons:  0,
			Shields:  2,
			Cargo:    10,
		},
	}
	sg := &game.ShipGroup{
		Number: 1,
		Tech: map[game.Tech]float64{
			game.TechDrive:   1.0,
			game.TechWeapons: 1.0,
			game.TechShields: 1.0,
			game.TechCargo:   1.0,
		},
		Load: 0.0,
	}
	em := Freighter.EmptyMass()
	assert.Equal(t, 0.0, sg.CarryingMass())
	assert.Equal(t, em, sg.FullMass(Freighter))

	sg.Load = 10.0
	assert.Equal(t, 10.0, sg.CarryingMass())
	assert.Equal(t, em+10.0, sg.FullMass(Freighter))

	sg.SetTechLevel(game.TechCargo, 2.5)
	assert.Equal(t, 4.0, sg.CarryingMass())
	assert.Equal(t, em+4.0, sg.FullMass(Freighter))
}

func TestSpeed(t *testing.T) {
	Freighter := &game.ShipType{
		ShipTypeReport: game.ShipTypeReport{
			Name:     "Freighter",
			Drive:    8,
			Armament: 0,
			Weapons:  0,
			Shields:  2,
			Cargo:    10,
		},
	}
	sg := &game.ShipGroup{
		Number: 1,
		Tech: map[game.Tech]float64{
			game.TechDrive:   1.0,
			game.TechWeapons: 1.0,
			game.TechShields: 1.0,
			game.TechCargo:   1.0,
		},
		Load: 0.0,
	}
	assert.Equal(t, 8.0, sg.Speed(Freighter))
	sg.Load = 5.0
	assert.Equal(t, 6.4, sg.Speed(Freighter))
	sg.SetTechLevel(game.TechDrive, 1.5)
	assert.Equal(t, 9.6, sg.Speed(Freighter))
	sg.Load = 10
	sg.SetTechLevel(game.TechCargo, 1.5)
	assert.Equal(t, 9.0, sg.Speed(Freighter))
}

func TestBombingPower(t *testing.T) {
	BattleStation := game.ShipType{
		ShipTypeReport: game.ShipTypeReport{
			Name:     "Battle_Station",
			Drive:    60.0,
			Armament: 3,
			Weapons:  30.0,
			Shields:  100.0,
			Cargo:    0.0,
		},
	}
	sg := game.ShipGroup{
		Number: 1,
		Tech: map[game.Tech]float64{
			game.TechDrive:   1.0,
			game.TechWeapons: 1.0,
			game.TechShields: 1.0,
			game.TechCargo:   1.0,
		},
	}
	assert.Equal(t, 139.295, number.Fixed3(sg.BombingPower(&BattleStation)))
	sg.Number = 2
	assert.Equal(t, 278.590, number.Fixed3(sg.BombingPower(&BattleStation)))
}

func TestDriveEffective(t *testing.T) {
	tc := []struct {
		driveShipType        float64
		driveTech            float64
		expectDriveEffective float64
	}{
		{1, 1, 1},
		{1, 2, 2},
		{2, 1, 2},
		{0, 1, 0},
		{0, 1.5, 0},
		{0, 10, 0},
		{1.5, 1.5, 2.25},
	}
	for i := range tc {
		someShip := game.ShipType{
			ShipTypeReport: game.ShipTypeReport{
				Drive:    tc[i].driveShipType,
				Armament: rand.UintN(30) + 1,
				Weapons:  rand.Float64()*30 + 1,
				Shields:  rand.Float64()*100 + 1,
				Cargo:    rand.Float64()*20 + 1,
			},
		}
		sg := game.ShipGroup{
			Number: rand.UintN(4) + 1,
			Tech: map[game.Tech]float64{
				game.TechDrive:   tc[i].driveTech,
				game.TechWeapons: rand.Float64()*5 + 1,
				game.TechShields: rand.Float64()*5 + 1,
				game.TechCargo:   rand.Float64()*5 + 1,
			},
		}
		assert.Equal(t, tc[i].expectDriveEffective, sg.DriveEffective(&someShip))
	}
}

func TestShipGroupEqual(t *testing.T) {
	fleetId := uuid.New()
	someUUID := uuid.New()
	mat := game.CargoMaterial
	cap := game.CargoCapital
	left := &game.ShipGroup{
		Index:  1,
		Number: 1,

		OwnerID:   uuid.New(),
		TypeID:    uuid.New(),
		FleetID:   &fleetId,
		CargoType: &mat,
		Load:      123.45,
		Tech: map[game.Tech]float64{
			game.TechDrive:   1.0,
			game.TechWeapons: 1.0,
			game.TechShields: 1.0,
			game.TechCargo:   1.0,
		},
	}

	// essential properties
	right := *left
	assert.True(t, left.Equal(right))

	left.OwnerID = someUUID
	assert.False(t, left.Equal(right))

	right = *left
	left.TypeID = someUUID
	assert.False(t, left.Equal(right))

	right = *left
	left.FleetID = &someUUID
	assert.False(t, left.Equal(right))

	right = *left
	left.FleetID = nil
	assert.False(t, left.Equal(right))

	right = *left
	left.StateInSpace = &game.InSpace{
		Origin: 1,
		Range:  1,
	}
	assert.False(t, left.Equal(right))

	right = *left
	left.CargoType = &cap
	assert.False(t, left.Equal(right))

	right = *left
	left.CargoType = nil
	assert.False(t, left.Equal(right))

	right = *left
	left.Load = 45.123
	assert.False(t, left.Equal(right))

	right = *left
	left.SetTechLevel(game.TechDrive, 1.1)
	assert.Equal(t, 1.1, left.TechLevel(game.TechDrive))
	assert.False(t, left.Equal(right))

	right = *left
	left.SetTechLevel(game.TechWeapons, 1.1)
	assert.Equal(t, 1.1, left.TechLevel(game.TechWeapons))
	assert.False(t, left.Equal(right))

	right = *left
	left.SetTechLevel(game.TechShields, 1.1)
	assert.Equal(t, 1.1, left.TechLevel(game.TechShields))
	assert.False(t, left.Equal(right))

	right = *left
	left.SetTechLevel(game.TechCargo, 1.1)
	assert.Equal(t, 1.1, left.TechLevel(game.TechCargo))
	assert.False(t, left.Equal(right))

	// non-essential properties
	right = *left

	left.Index = 2
	assert.True(t, left.Equal(right))

	// dirty hack to equalize loads
	left.Number = 5
	left.Load = right.Load / float64(right.Number) * float64(left.Number)
	assert.True(t, left.Equal(right))
}