package controller

import (
	"github.com/google/uuid"
	"github.com/iliadenisov/galaxy/internal/model/game"
	"github.com/iliadenisov/galaxy/internal/model/report"
)

func TransformBattle(c *Cache, b *Battle) *report.BattleReport {
	r := &report.BattleReport{
		ID:         b.ID,
		Planet:     b.Planet,
		PlanetName: c.MustPlanet(b.Planet).Name,
		Races:      make(map[int]uuid.UUID),
		Ships:      make(map[int]report.BattleReportGroup),
		Protocol:   make([]report.BattleActionReport, len(b.Protocol)),
	}

	cacheShipClass := make(map[uuid.UUID]int)
	cacheRaceName := make(map[uuid.UUID]int)

	addShipGroup := func(groupId int, inBattle bool) int {
		shipClass := c.ShipGroupShipClass(groupId)
		sg := c.ShipGroup(groupId)
		itemNumber := len(r.Ships)
		r.Ships[itemNumber] = report.BattleReportGroup{
			OwnerID:       sg.OwnerID,
			Race:          c.g.Race[c.RaceIndex(sg.OwnerID)].Name,
			InBattle:      inBattle,
			Number:        b.initialNumbers[groupId],
			NumberLeft:    sg.Number,
			ClassName:     shipClass.Name,
			LoadType:      sg.CargoString(),
			LoadQuantity:  report.F(sg.Load.F()),
			DriveTech:     report.F(sg.TechLevel(game.TechDrive).F()),
			ClassArmament: shipClass.Armament,
			WeaponsTech:   report.F(sg.TechLevel(game.TechWeapons).F()),
			ShieldsTech:   report.F(sg.TechLevel(game.TechShields).F()),
			CargoTech:     report.F(sg.TechLevel(game.TechCargo).F()),
			ClassMass:     report.F(shipClass.EmptyMass()),
		}
		cacheShipClass[shipClass.ID] = itemNumber
		return itemNumber
	}

	ship := func(groupId int) int {
		shipClass := c.ShipGroupShipClass(groupId)
		if v, ok := cacheShipClass[shipClass.ID]; ok {
			return v
		} else {
			return addShipGroup(groupId, true)
		}
	}

	race := func(groupId int) int {
		race := c.ShipGroupOwnerRace(groupId)
		if v, ok := cacheRaceName[race.ID]; ok {
			return v
		} else {
			itemNumber := len(r.Races)
			r.Races[itemNumber] = race.ID
			cacheRaceName[race.ID] = itemNumber
			return itemNumber
		}
	}

	for i := range b.Protocol {
		r.Protocol[i] = report.BattleActionReport{
			Attacker:          race(b.Protocol[i].Attacker),
			AttackerShipClass: ship(b.Protocol[i].Attacker),
			Defender:          race(b.Protocol[i].Defender),
			DefenderShipClass: ship(b.Protocol[i].Defender),
			Destroyed:         b.Protocol[i].Destroyed,
		}
	}

	for sgi, inBattle := range b.observerGroups {
		if !inBattle {
			addShipGroup(sgi, false)
		}
	}

	return r
}