package game

import (
	"iter"
	"math"
	"slices"

	"github.com/google/uuid"
	e "github.com/iliadenisov/galaxy/internal/error"
)

type Fleet struct {
	ID      uuid.UUID `json:"id"`
	OwnerID uuid.UUID `json:"ownerId"`
	Name    string    `json:"name"`

	Destination uint     `json:"destination"`
	Origin      *uint    `json:"origin,omitempty"`
	Range       *float64 `json:"range,omitempty"`
}

// TODO: Hello! Wanna know fleet's speed? Good. Implement & test this func first.
func (g Game) FleetSpeed(fl Fleet) float64 {
	result := math.MaxFloat64
	for sg := range g.ShipGroups {
		if g.ShipGroups[sg].FleetID == nil || *g.ShipGroups[sg].FleetID != fl.ID {
			continue
		}
		st := g.mustShipType(g.ShipGroups[sg].TypeID)
		typeSpeed := g.ShipGroups[sg].Speed(st)
		if typeSpeed < result {
			result = typeSpeed
		}
	}
	return result
}

func (g *Game) JoinShipGroupToFleet(raceName, fleetName string, group, count uint) error {
	ri, err := g.raceIndex(raceName)
	if err != nil {
		return err
	}
	return g.joinShipGroupToFleetInternal(ri, fleetName, group, count)
}

func (g *Game) JoinFleets(raceName, fleetSourceName, fleetTargetName string) error {
	ri, err := g.raceIndex(raceName)
	if err != nil {
		return err
	}
	return g.joinFleetsInternal(ri, fleetSourceName, fleetTargetName)
}

func (g *Game) joinShipGroupToFleetInternal(ri int, fleetName string, group, count uint) (err error) {
	name, ok := validateTypeName(fleetName)
	if !ok {
		return e.NewEntityTypeNameValidationError("%q", name)
	}
	sgi := -1
	var maxIndex uint
	for i, sg := range g.listIndexShipGroups(ri) {
		if sgi < 0 && sg.Index == group {
			sgi = i
		}
		if sg.Index > maxIndex {
			maxIndex = sg.Index
		}
	}
	if sgi < 0 {
		return e.NewEntityNotExistsError("group #%d", group)
	}

	if g.ShipGroups[sgi].State() != StateInOrbit {
		return e.NewShipsBusyError()
	}

	if g.ShipGroups[sgi].Number < count {
		return e.NewJoinFleetGroupNumberNotEnoughError("%d<%d", g.ShipGroups[sgi].Number, count)
	}

	fi := g.fleetIndex(ri, name)
	if fi < 0 {
		fi, err = g.createFleet(ri, name, g.ShipGroups[sgi].Destination)
		if err != nil {
			return err
		}
	} else {
		if g.Fleets[fi].Destination != g.ShipGroups[sgi].Destination || g.Fleets[fi].Origin != nil || g.Fleets[fi].Range != nil {
			return e.NewShipsNotOnSamePlanetError("fleet: %s", fleetName)
		}
	}

	// FIXME: if g.ShipGroups[sgi].FleetID != nil { // delete old fleet if empty, ALSO mind breaking group }
	if count > 0 && g.ShipGroups[sgi].Number != count {
		newGroup := g.ShipGroups[sgi]
		newGroup.Number -= count
		g.ShipGroups[sgi].Number = count
		newGroup.Index = maxIndex + 1
		g.ShipGroups = append(g.ShipGroups, newGroup)
	}

	g.ShipGroups[sgi].FleetID = &g.Fleets[fi].ID
	return nil
}

func (g *Game) createFleet(ri int, name string, planetNumber uint) (int, error) {
	n, ok := validateTypeName(name)
	if !ok {
		return 0, e.NewEntityTypeNameValidationError("%q", n)
	}
	if fl := g.fleetIndex(ri, n); fl >= 0 {
		return 0, e.NewEntityTypeNameDuplicateError("fleet %w", g.Fleets[fl].Name)
	}
	g.Fleets = append(g.Fleets, Fleet{
		ID:          uuid.New(),
		OwnerID:     g.Race[ri].ID,
		Name:        n,
		Destination: planetNumber,
	})
	return len(g.Fleets) - 1, nil
}

func (g *Game) joinFleetsInternal(ri int, fleetSourceName, fleetTargetName string) (err error) {
	fiSource := g.fleetIndex(ri, fleetSourceName)
	if fiSource < 0 {
		return e.NewEntityNotExistsError("source fleet %s", fleetSourceName)
	}
	fiTarget := g.fleetIndex(ri, fleetTargetName)
	if fiTarget < 0 {
		return e.NewEntityNotExistsError("target fleet %s", fleetTargetName)
	}
	if g.Fleets[fiSource].Destination != g.Fleets[fiTarget].Destination ||
		g.Fleets[fiSource].Origin != nil || g.Fleets[fiTarget].Origin != nil ||
		g.Fleets[fiSource].Range != nil || g.Fleets[fiTarget].Range != nil {
		return e.NewShipsNotOnSamePlanetError()
	}
	for sgi, sg := range g.listIndexShipGroups(ri) {
		if sg.FleetID != nil && *sg.FleetID == g.Fleets[fiSource].ID {
			g.ShipGroups[sgi].FleetID = &g.Fleets[fiTarget].ID
		}
	}
	return g.deleteFleetSafe(ri, fleetSourceName)
}

func (g *Game) deleteFleetSafe(ri int, name string) error {
	fi := g.fleetIndex(ri, name)
	if fi < 0 {
		return e.NewEntityNotExistsError("fleet %s", name)
	}
	for sgi := range g.ShipGroups {
		if g.ShipGroups[sgi].FleetID != nil && *g.ShipGroups[sgi].FleetID == g.Fleets[fi].ID {
			return e.NewEntityInUseError("fleet %s: race %s, group #%d", name, g.Race[ri].Name, g.ShipGroups[sgi].Number)
		}
	}
	g.Fleets = append(g.Fleets[:fi], g.Fleets[fi+1:]...)
	return nil
}

func (g Game) fleetIndex(ri int, name string) int {
	return slices.IndexFunc(g.Fleets, func(f Fleet) bool { return f.OwnerID == g.Race[ri].ID && f.Name == name })
}

func (g Game) listFleets(ri int) iter.Seq[Fleet] {
	return func(yield func(Fleet) bool) {
		for _, fl := range g.listIndexFleets(ri) {
			if !yield(fl) {
				return
			}
		}
	}
}

func (g Game) listIndexFleets(ri int) iter.Seq2[int, Fleet] {
	return func(yield func(int, Fleet) bool) {
		for i := range g.Fleets {
			if g.Fleets[i].OwnerID == g.Race[ri].ID {
				if !yield(i, g.Fleets[i]) {
					return
				}
			}
		}
	}
}