package controller

import (
	"strings"

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

func (c Controller) RaceID(actor string) (uuid.UUID, error) {
	ri, err := c.Cache.validRace(actor)
	if err != nil {
		return uuid.Nil, err
	}
	return c.Cache.g.Race[ri].ID, nil
}

func (c Controller) QuitGame(actor string) error {
	ri, err := c.Cache.validRace(actor)
	if err != nil {
		return err
	}
	c.Cache.g.Race[ri].TTL = 3
	return nil
}

func (c Controller) GiveVotes(actor, acceptor string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rec, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	c.Cache.g.Race[ri].VoteFor = c.Cache.g.Race[rec].ID
	return nil
}

func (c Controller) UpdateRelation(actor, acceptor string, v string) error {
	rel, ok := game.ParseRelation(v)
	if !ok {
		return e.NewUnknownRelationError(v)
	}
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	other, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	return c.Cache.UpdateRelation(ri, other, rel)
}

func (c *Controller) CreateShipType(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.ShipClassCreate(ri, typeName, drive, ammo, weapons, shileds, cargo)
}

func (c *Controller) MergeShipType(actor, name, targetName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipClassMerge(ri, name, targetName)
}

func (c *Controller) DeleteShipType(actor, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipClassRemove(ri, typeName)
}

func (c *Controller) LoadCargo(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	ct, ok := game.CargoTypeSet[cargoType]
	if !ok {
		return e.NewCargoTypeInvalidError(cargoType)
	}
	return c.Cache.shipGroupLoad(ri, groupIndex, ct, ships, quantity)
}

func (c *Controller) UnloadCargo(actor string, groupIndex uint, ships uint, quantity float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipGroupUnload(ri, groupIndex, ships, quantity)
}

func (c *Controller) SendGroup(actor string, groupIndex, planetNumber, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipGroupSend(ri, groupIndex, planetNumber, quantity)
}

func (c *Controller) UpgradeGroup(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipGroupUpgrade(ri, groupIndex, techInput, limitShips, limitLevel)
}

func (c *Controller) JoinEqualGroups(actor string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	c.Cache.shipGroupMerge(ri)
	return nil
}

func (c *Controller) BreakGroup(actor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.ShipGroupBreak(ri, groupIndex, quantity)
}

func (c *Controller) DisassembleGroup(actor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.shipGroupDismantle(ri, groupIndex, quantity)
}

func (c *Controller) TransferGroup(actor, acceptor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	riAccept, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	return c.Cache.shipGroupTransfer(ri, riAccept, groupIndex, quantity)
}

func (c *Controller) JoinShipGroupToFleet(actor, fleetName string, group, count uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.ShipGroupJoinFleet(ri, fleetName, group, count)
}

func (c *Controller) JoinFleets(actor, fleetSourceName, fleetTargetName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.fleetMerge(ri, fleetSourceName, fleetTargetName)
}

func (c *Controller) SendFleet(actor, fleetName string, planetNumber uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	fi, ok := c.Cache.fleetIndex(ri, fleetName)
	if !ok {
		return e.NewEntityNotExistsError("fleet %q", fleetName)
	}
	return c.Cache.FleetSend(ri, fi, planetNumber)
}

func (c *Controller) CreateScience(actor, typeName string, drive, weapons, shields, cargo float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.ScienceCreate(ri, typeName, drive, weapons, shields, cargo)
}

func (c *Controller) DeleteScience(actor, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.ScienceRemove(ri, typeName)
}

func (c *Controller) RenamePlanet(actor string, planetNumber int, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.PlanetRename(ri, planetNumber, typeName)
}

func (c *Controller) PlanetProduction(actor string, planetNumber int, prodType, subject string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	var prod game.ProductionType
	switch game.ProductionType(strings.ToUpper(prodType)) {
	case game.ProductionMaterial:
		prod = game.ProductionMaterial
	case game.ProductionCapital:
		prod = game.ProductionCapital
	case game.ResearchDrive:
		prod = game.ResearchDrive
	case game.ResearchWeapons:
		prod = game.ResearchWeapons
	case game.ResearchShields:
		prod = game.ResearchShields
	case game.ResearchCargo:
		prod = game.ResearchCargo
	case game.ResearchScience:
		prod = game.ResearchScience
	case game.ProductionShip:
		prod = game.ProductionShip
	default:
		return e.NewProductionInvalidError(prodType)
	}
	return c.Cache.PlanetProduce(ri, planetNumber, prod, subject)
}

func (c *Controller) SetRoute(actor, loadType string, origin, destination uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rt, ok := game.RouteTypeSet[loadType]
	if !ok {
		return e.NewCargoTypeInvalidError(loadType)
	}
	return c.Cache.PlanetRouteSet(ri, rt, origin, destination)
}

func (c *Controller) RemoveRoute(actor, loadType string, origin uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rt, ok := game.RouteTypeSet[loadType]
	if !ok {
		return e.NewCargoTypeInvalidError(loadType)
	}
	return c.Cache.PlanetRouteRemove(ri, rt, origin)
}