using System.Text.Json.Serialization;
using Core.Helpers;
using Core.Models.Eft.Common;
using Core.Models.Eft.Common.Tables;
using Core.Models.Enums;
using Core.Models.Spt.Config;
using Core.Models.Utils;
using Core.Servers;
using Core.Services;
using Core.Utils;
using Core.Utils.Cloners;
using Core.Utils.Collections;
using SptCommon.Annotations;

namespace Core.Generators;

[Injectable]
public class LocationLootGenerator(
    ISptLogger<LocationLootGenerator> _logger,
    RandomUtil _randomUtil,
    MathUtil _mathUtil,
    HashUtil _hashUtil,
    ItemHelper _itemHelper,
    InventoryHelper _inventoryHelper,
    DatabaseService _databaseService,
    ContainerHelper _containerHelper,
    PresetHelper _presetHelper,
    LocalisationService _localisationService,
    SeasonalEventService _seasonalEventService,
    ItemFilterService _itemFilterService,
    ConfigServer _configServer,
    ICloner _cloner
)
{
    protected LocationConfig _locationConfig = _configServer.GetConfig<LocationConfig>();
    protected SeasonalEventConfig _seasonalEventConfig = _configServer.GetConfig<SeasonalEventConfig>();

    /// Create a list of container objects with randomised loot
    /// <param name="locationBase">Map base to generate containers for</param>
    /// <param name="staticAmmoDist">Static ammo distribution</param>
    /// <returns>List of container objects</returns>
    public List<SpawnpointTemplate> GenerateStaticContainers(LocationBase locationBase,
        Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist)
    {
        var staticLootItemCount = 0;
        var result = new List<SpawnpointTemplate>();
        var locationId = locationBase.Id.ToLower();

        var mapData = _databaseService.GetLocation(locationId);

        var staticWeaponsOnMapClone = _cloner.Clone(mapData.StaticContainers.Value.StaticWeapons);
        if (staticWeaponsOnMapClone is null)
        {
            _logger.Error(
                _localisationService.GetText("location-unable_to_find_static_weapon_for_map", locationBase.Name)
            );
        }

        // Add mounted weapons to output loot
        result.AddRange(staticWeaponsOnMapClone);

        var allStaticContainersOnMapClone = _cloner.Clone(mapData.StaticContainers.Value.StaticContainers);
        if (allStaticContainersOnMapClone is null)
        {
            _logger.Error(
                _localisationService.GetText("location-unable_to_find_static_container_for_map", locationBase.Name)
            );
        }

        // Containers that MUST be added to map (e.g. quest containers)
        var staticForcedOnMapClone = _cloner.Clone(mapData.StaticContainers.Value.StaticForced);
        if (staticForcedOnMapClone is null)
        {
            _logger.Error(
                _localisationService.GetText(
                    "location-unable_to_find_forced_static_data_for_map",
                    locationBase.Name
                )
            );
        }

        // Remove christmas items from loot data
        if (!_seasonalEventService.ChristmasEventEnabled())
        {
            allStaticContainersOnMapClone = allStaticContainersOnMapClone.Where(
                    item => !_seasonalEventConfig.ChristmasContainerIds.Contains(item.Template.Id)
                )
                .ToList();
        }

        var staticRandomisableContainersOnMap = GetRandomisableContainersOnMap(allStaticContainersOnMapClone);

        // Keep track of static loot count
        var staticContainerCount = 0;

        // Find all 100% spawn containers
        var staticLootDist = mapData.StaticLoot;
        var guaranteedContainers = GetGuaranteedContainers(allStaticContainersOnMapClone);
        staticContainerCount += guaranteedContainers.Count;

        // Add loot to guaranteed containers and add to result
        foreach (var container in guaranteedContainers)
        {
            var containerWithLoot = AddLootToContainer(
                container,
                staticForcedOnMapClone,
                staticLootDist.Value,
                staticAmmoDist,
                locationId
            );
            result.Add(containerWithLoot.Template);

            staticLootItemCount += containerWithLoot.Template.Items.Count;
        }

        _logger.Debug($"Added {guaranteedContainers.Count} guaranteed containers");

        // Randomisation is turned off globally or just turned off for this map
        if (
            !(
                _locationConfig.ContainerRandomisationSettings.Enabled &&
                _locationConfig.ContainerRandomisationSettings.Maps[locationId]
            )
        )
        {
            _logger.Debug(
                $"Container randomisation disabled, Adding {staticRandomisableContainersOnMap.Count} containers to {locationBase.Name}"
            );
            foreach (var container in staticRandomisableContainersOnMap)
            {
                var containerWithLoot = AddLootToContainer(
                    container,
                    staticForcedOnMapClone,
                    staticLootDist.Value,
                    staticAmmoDist,
                    locationId
                );
                result.Add(containerWithLoot.Template);

                staticLootItemCount += containerWithLoot.Template.Items.Count;
            }

            _logger.Success($"A total of {staticLootItemCount} static items spawned");

            return result;
        }

        // Group containers by their groupId
        if (mapData.StaticContainer is null)
        {
            _logger.Warning(_localisationService.GetText("location-unable_to_generate_static_loot", locationId));

            return result;
        }

        var mapping = GetGroupIdToContainerMappings(mapData.StaticContainer, staticRandomisableContainersOnMap);

        // For each of the container groups, choose from the pool of containers, hydrate container with loot and add to result array
        foreach (var (key, data) in mapping)
        {
            // Count chosen was 0, skip
            if (data.ChosenCount == 0)
            {
                continue;
            }

            if (data.ContainerIdsWithProbability.Count == 0)
            {
                _logger.Debug($"`Group: {key} has no containers with< 100 % spawn chance to choose from, skipping");

                continue;
            }

            // EDGE CASE: These are containers without a group and have a probability < 100%
            if (key == "")
            {
                var containerIdsCopy = _cloner.Clone(data.ContainerIdsWithProbability);
                // Roll each containers probability, if it passes, it gets added
                data.ContainerIdsWithProbability = new Dictionary<string, double>();
                foreach (var containerId in containerIdsCopy)
                    if (_randomUtil.GetChance100(containerIdsCopy[containerId.Key] * 100))
                    {
                        data.ContainerIdsWithProbability[containerId.Key] = containerIdsCopy[containerId.Key];
                    }

                // Set desired count to size of array (we want all containers chosen)
                data.ChosenCount = data.ContainerIdsWithProbability.Count;

                // EDGE CASE: chosen container count could be 0
                if (data.ChosenCount == 0)
                {
                    continue;
                }
            }

            // Pass possible containers into function to choose some
            var chosenContainerIds = GetContainersByProbability(key, data);
            foreach (var chosenContainerId in chosenContainerIds)
            {
                // Look up container object from full list of containers on map
                var containerObject = staticRandomisableContainersOnMap.FirstOrDefault(
                    staticContainer => staticContainer.Template.Id == chosenContainerId
                );
                if (containerObject is null)
                {
                    _logger.Debug(
                        $"Container: {chosenContainerId} not found in staticRandomisableContainersOnMap, this is bad"
                    );
                    continue;
                }

                // Add loot to container and push into result object
                var containerWithLoot = AddLootToContainer(
                    containerObject,
                    staticForcedOnMapClone,
                    staticLootDist.Value,
                    staticAmmoDist,
                    locationId
                );
                result.Add(containerWithLoot.Template);
                staticContainerCount++;

                staticLootItemCount += containerWithLoot.Template.Items.Count;
            }
        }

        _logger.Success("A total of { staticLootItemCount}static items spawned");

        _logger.Success(
            _localisationService.GetText("location-containers_generated_success", staticContainerCount)
        );

        return result;
    }

    /// <summary>
    ///     Get containers with a non-100% chance to spawn OR are NOT on the container type randomistion blacklist
    /// </summary>
    /// <param name="staticContainers"></param>
    /// <returns>StaticContainerData array</returns>
    protected List<StaticContainerData> GetRandomisableContainersOnMap(List<StaticContainerData> staticContainers)
    {
        return staticContainers.Where(
                staticContainer =>
                    staticContainer.Probability != 1 &&
                    !staticContainer.Template.IsAlwaysSpawn.GetValueOrDefault(false) &&
                    !_locationConfig.ContainerRandomisationSettings.ContainerTypesToNotRandomise.Contains(
                        staticContainer.Template.Items[0].Template
                    )
            )
            .ToList();
    }

    /// <summary>
    ///     Get containers with 100% spawn rate or have a type on the randomistion ignore list
    /// </summary>
    /// <param name="staticContainersOnMap"></param>
    /// <returns>IStaticContainerData array</returns>
    protected List<StaticContainerData> GetGuaranteedContainers(List<StaticContainerData> staticContainersOnMap)
    {
        return staticContainersOnMap.Where(
                staticContainer =>
                    staticContainer.Probability == 1 ||
                    staticContainer.Template.IsAlwaysSpawn.GetValueOrDefault(false) ||
                    _locationConfig.ContainerRandomisationSettings.ContainerTypesToNotRandomise.Contains(
                        staticContainer.Template.Items[0].Template
                    )
            )
            .ToList();
    }

    /// <summary>
    ///     Choose a number of containers based on their probabilty value to fulfil the desired count in
    ///     containerData.chosenCount
    /// </summary>
    /// <param name="groupId">Name of the group the containers are being collected for</param>
    /// <param name="containerData">Containers and probability values for a groupId</param>
    /// <returns>List of chosen container Ids</returns>
    protected List<string> GetContainersByProbability(string groupId, ContainerGroupCount containerData)
    {
        var chosenContainerIds = new List<string>();

        var containerIds = containerData.ContainerIdsWithProbability.Keys.ToList();
        if (containerData.ChosenCount > containerIds.Count)
        {
            _logger.Debug(
                $"Group: {groupId} wants {containerData.ChosenCount} containers but pool only has {containerIds.Count}, add what's available"
            );
            return containerIds;
        }

        // Create probability array with all possible container ids in this group and their relative probability of spawning
        var containerDistribution =
            new ProbabilityObjectArray<ProbabilityObject<string, double>, string, double>(_mathUtil, _cloner, []);
        foreach (var x in containerIds)
        {
            var value = containerData.ContainerIdsWithProbability[x];
            containerDistribution.Add(new ProbabilityObject<string, double>(x, value, value));
        }

        chosenContainerIds.AddRange(containerDistribution.Draw((int)containerData.ChosenCount));

        return chosenContainerIds;
    }

    /// <summary>
    ///     Get a mapping of each groupid and the containers in that group + count of containers to spawn on map
    /// </summary>
    /// <param name="containersGroups">Container group values</param>
    /// <returns>dictionary keyed by groupId</returns>
    protected Dictionary<string, ContainerGroupCount> GetGroupIdToContainerMappings(
        StaticContainer staticContainerGroupData,
        List<StaticContainerData> staticContainersOnMap)
    {
        // Create dictionary of all group ids and choose a count of containers the map will spawn of that group
        var mapping = new Dictionary<string, ContainerGroupCount>();
        foreach (var groupKvP in staticContainerGroupData.ContainersGroups)
        {
            var groupData = staticContainerGroupData.ContainersGroups[groupKvP.Key];
            if (!mapping.ContainsKey(groupKvP.Key))
            {
                mapping[groupKvP.Key] = new ContainerGroupCount
                {
                    ContainerIdsWithProbability = new Dictionary<string, double>(),
                    ChosenCount = _randomUtil.GetInt(
                        (int)Math.Round(
                            groupData.MinContainers.Value *
                            _locationConfig.ContainerRandomisationSettings.ContainerGroupMinSizeMultiplier
                        ),
                        (int)Math.Round(
                            groupData.MaxContainers.Value *
                            _locationConfig.ContainerRandomisationSettings.ContainerGroupMaxSizeMultiplier
                        )
                    )
                };
            }
        }

        // Add an empty group for containers without a group id but still have a < 100% chance to spawn
        // Likely bad BSG data, will be fixed...eventually, example of the groupids: `NEED_TO_BE_FIXED1`,`NEED_TO_BE_FIXED_SE02`, `NEED_TO_BE_FIXED_NW_01`
        mapping[""] = new ContainerGroupCount { ChosenCount = -1 };

        // Iterate over all containers and add to group keyed by groupId
        // Containers without a group go into a group with empty key ""
        foreach (var container in staticContainersOnMap)
        {
            var groupData = staticContainerGroupData.Containers[container.Template.Id];
            if (groupData is null)
            {
                _logger.Error(
                    _localisationService.GetText(
                        "location-unable_to_find_container_in_statics_json",
                        container.Template.Id
                    )
                );

                continue;
            }

            if (container.Probability == 1)
            {
                _logger.Debug(
                    $"Container {container.Template.Id} with group ${groupData.GroupId} had 100 % chance to spawn was picked as random container, skipping"
                );

                continue;
            }

            mapping[groupData.GroupId].ContainerIdsWithProbability[container.Template.Id] = container.Probability.Value;
        }

        return mapping;
    }

    /// <summary>
    ///     Choose loot to put into a static container based on weighting
    ///     Handle forced items + seasonal item removal when not in season
    /// </summary>
    /// <param name="staticContainer">The container itself we will add loot to</param>
    /// <param name="staticForced">Loot we need to force into the container</param>
    /// <param name="staticLootDist">staticLoot.json</param>
    /// <param name="staticAmmoDist">staticAmmo.json</param>
    /// <param name="locationName">Name of the map to generate static loot for</param>
    /// <returns>StaticContainerData</returns>
    protected StaticContainerData AddLootToContainer(StaticContainerData staticContainer,
        List<StaticForced>? staticForced,
        Dictionary<string, StaticLootDetails> staticLootDist,
        Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist, string locationName
    )
    {
        var containerClone = _cloner.Clone(staticContainer);
        var containerTpl = containerClone.Template.Items[0].Template;

        // Create new unique parent id to prevent any collisions
        var parentId = _hashUtil.Generate();
        containerClone.Template.Root = parentId;
        containerClone.Template.Items[0].Id = parentId;

        var containerMap = GetContainerMapping(containerTpl);

        // Choose count of items to add to container
        var itemCountToAdd = GetWeightedCountOfContainerItems(containerTpl, staticLootDist, locationName);

        // Get all possible loot items for container
        var containerLootPool = GetPossibleLootItemsForContainer(containerTpl, staticLootDist);

        // Some containers need to have items forced into it (quest keys etc)
        var tplsForced = staticForced
            .Where((forcedStaticProp) => forcedStaticProp.ContainerId == containerClone.Template.Id)
            .Select((x) => x.ItemTpl);

        // Draw random loot
        // Allow money to spawn more than once in container
        var failedToFitCount = 0;
        var locklist = _itemHelper.GetMoneyTpls();

        // Choose items to add to container, factor in weighting + lock money down
        // Filter out items picked that're already in the above `tplsForced` array
        var chosenTpls = containerLootPool
            .Draw(itemCountToAdd, _locationConfig.AllowDuplicateItemsInStaticContainers, locklist)
            .Where((tpl) => !tplsForced.Contains(tpl));

        // Add forced loot to chosen item pool
        var tplsToAddToContainer = tplsForced.Concat(chosenTpls);
        foreach (var tplToAdd in tplsToAddToContainer)
        {
            var chosenItemWithChildren = CreateStaticLootItem(tplToAdd, staticAmmoDist, parentId);
            if (chosenItemWithChildren is null)
            {
                continue;
            }

            var items = _locationConfig.TplsToStripChildItemsFrom.Contains(tplToAdd)
                ? [chosenItemWithChildren.Items[0]] // Strip children from parent
                : chosenItemWithChildren.Items;
            var width = chosenItemWithChildren.Width;
            var height = chosenItemWithChildren.Height;

            // look for open slot to put chosen item into
            var result = _containerHelper.FindSlotForItem(containerMap, (int)width, (int)height);
            if (!result.Success.GetValueOrDefault(false))
            {
                if (failedToFitCount >= _locationConfig.FitLootIntoContainerAttempts)
                {
                    // x attempts to fit an item, container is probably full, stop trying to add more
                    break;
                }

                // Can't fit item, skip
                failedToFitCount++;

                continue;
            }

            _containerHelper.FillContainerMapWithItem(
                containerMap,
                result.X.Value,
                result.Y.Value,
                (int)width,
                (int)height,
                result.Rotation.GetValueOrDefault(false)
            );

            var rotation = result.Rotation.GetValueOrDefault(false) ? 1 : 0;

            items[0].SlotId = "main";
            items[0].Location = new ItemLocation{ X = result.X, Y = result.Y, R = rotation };

            // Add loot to container before returning
            foreach (var item in items)
            {
                containerClone.Template.Items.Add(item);
            }
        }

        return containerClone;
    }

    /// <summary>
    ///     Get a 2D grid of a container's item slots
    /// </summary>
    /// <param name="containerTpl">Tpl id of the container</param>
    protected int[][] GetContainerMapping(string containerTpl)
    {
        // Get template from db
        var containerTemplate = _itemHelper.GetItem(containerTpl).Value;

        // Get height/width
        var height = containerTemplate.Properties.Grids[0].Props.CellsV;
        var width = containerTemplate.Properties.Grids[0].Props.CellsH;

        return _inventoryHelper.GetBlankContainerMap(height.Value, width.Value);
    }

    /// <summary>
    ///     Look up a containers itemcountDistribution data and choose an item count based on the found weights
    /// </summary>
    /// <param name="containerTypeId">Container to get item count for</param>
    /// <param name="staticLootDist">staticLoot.json</param>
    /// <param name="locationName">Map name (to get per-map multiplier for from config)</param>
    /// <returns>item count</returns>
    protected int GetWeightedCountOfContainerItems(string containerTypeId,
        Dictionary<string, StaticLootDetails> staticLootDist, string locationName)
    {
        // Create probability array to calcualte the total count of lootable items inside container
        var itemCountArray =
            new ProbabilityObjectArray<ProbabilityObject<int, float?>, int, float?>(_mathUtil, _cloner, []);
        var countDistribution = staticLootDist[containerTypeId]?.ItemCountDistribution;
        if (countDistribution is null)
        {
            _logger.Warning(
                _localisationService.GetText(
                    "location-unable_to_find_count_distribution_for_container",
                    new
                    {
                        containerId = containerTypeId, locationName
                    }
                )
            );

            return 0;
        }

        foreach (var itemCountDistribution in countDistribution)
            // Add each count of items into array
            itemCountArray.Add(
                new ProbabilityObject<int, float?>(
                    itemCountDistribution.Count.Value,
                    itemCountDistribution.RelativeProbability.Value,
                    null
                )
            );

        return (int)Math.Round(GetStaticLootMultiplierForLocation(locationName) * itemCountArray.Draw()[0]);
    }

    /// <summary>
    ///     Get all possible loot items that can be placed into a container
    ///     Do not add seasonal items if found + current date is inside seasonal event
    /// </summary>
    /// <param name="containerTypeId">Container to get possible loot for</param>
    /// <param name="staticLootDist">staticLoot.json</param>
    /// <returns>ProbabilityObjectArray of item tpls + probabilty</returns>
    protected ProbabilityObjectArray<ProbabilityObject<string, float?>, string, float?> GetPossibleLootItemsForContainer(string containerTypeId,
        Dictionary<string, StaticLootDetails> staticLootDist) // TODO: Type Fuckery, return type was ProbabilityObjectArray<string, number>
    {
        var seasonalEventActive = _seasonalEventService.SeasonalEventEnabled();
        var seasonalItemTplBlacklist = _seasonalEventService.GetInactiveSeasonalEventItems();

        var itemDistribution =
            new ProbabilityObjectArray<ProbabilityObject<string, float?>, string, float?>(_mathUtil, _cloner, []);

        var itemContainerDistribution = staticLootDist[containerTypeId]?.ItemDistribution;
        if (itemContainerDistribution is null)
        {
            _logger.Warning(_localisationService.GetText("location-missing_item_distribution_data", containerTypeId));

            return itemDistribution;
        }

        foreach (var icd in itemContainerDistribution)
        {
            if (!seasonalEventActive && seasonalItemTplBlacklist.Contains(icd.Tpl))
            {
                // Skip seasonal event items if they're not enabled
                continue;
            }

            // Ensure no blacklisted lootable items are in pool
            if (_itemFilterService.IsLootableItemBlacklisted(icd.Tpl))
            {
                continue;
            }

            itemDistribution.Add(new ProbabilityObject<string, float?>(icd.Tpl, icd.RelativeProbability.Value, null));
        }

        return itemDistribution;
    }

    protected double GetLooseLootMultiplierForLocation(string location)
    {
        return _locationConfig.LooseLootMultiplier[location];
    }

    protected double GetStaticLootMultiplierForLocation(string location)
    {
        return _locationConfig.StaticLootMultiplier[location];
    }

    /// <summary>
    ///     Create array of loose + forced loot using probability system
    /// </summary>
    /// <param name="dynamicLootDist"></param>
    /// <param name="staticAmmoDist"></param>
    /// <param name="locationName">Location to generate loot for</param>
    /// <returns>Array of spawn points with loot in them</returns>
    public List<SpawnpointTemplate> GenerateDynamicLoot(LooseLoot dynamicLootDist,
        Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist,
        string locationName)
    {
        List<SpawnpointTemplate> loot = [];
        List<Spawnpoint> dynamicForcedSpawnPoints = [];

        // Remove christmas items from loot data
        if (!_seasonalEventService.ChristmasEventEnabled())
        {
            dynamicLootDist.Spawnpoints = dynamicLootDist.Spawnpoints.Where(
                    (point) => !point.Template.Id.StartsWith("christmas")
                )
                .ToList();
            dynamicLootDist.SpawnpointsForced = dynamicLootDist.SpawnpointsForced.Where(
                    (point) => !point.Template.Id.StartsWith("christmas")
                )
                .ToList();
        }

        // Build the list of forced loot from both `spawnpointsForced` and any point marked `IsAlwaysSpawn`
        dynamicForcedSpawnPoints.AddRange(dynamicLootDist.SpawnpointsForced);
        dynamicForcedSpawnPoints.AddRange(dynamicLootDist.Spawnpoints.Where((point) => point.Template.IsAlwaysSpawn ?? false));

        // Add forced loot
        AddForcedLoot(loot, dynamicForcedSpawnPoints, locationName, staticAmmoDist);

        var allDynamicSpawnpoints = dynamicLootDist.Spawnpoints;

        // Draw from random distribution
        var desiredSpawnpointCount = Math.Round(
            GetLooseLootMultiplerForLocation(locationName) *
            _randomUtil.GetNormallyDistributedRandomNumber(
                (double)dynamicLootDist.SpawnpointCount.Mean,
                (double)dynamicLootDist.SpawnpointCount.Std
            )
        );

        // Positions not in forced but have 100% chance to spawn
        List<Spawnpoint> guaranteedLoosePoints = [];

        var blacklistedSpawnpoints = _locationConfig.LooseLootBlacklist.GetValueOrDefault(locationName);
        var spawnpointArray = new ProbabilityObjectArray<ProbabilityObject<string, Spawnpoint>, string, Spawnpoint>(_mathUtil, _cloner, []);

        foreach (var spawnpoint in allDynamicSpawnpoints)
        {
            // Point is blacklsited, skip
            if (blacklistedSpawnpoints?.Contains(spawnpoint.Template.Id) ?? false)
            {
                _logger.Debug($"Ignoring loose loot location: {spawnpoint.Template.Id}");
                continue;
            }

            // We've handled IsAlwaysSpawn above, so skip them
            if (spawnpoint.Template.IsAlwaysSpawn ?? false)
            {
                continue;
            }

            // 100%, add it to guaranteed
            if (spawnpoint.Probability == 1)
            {
                guaranteedLoosePoints.Add(spawnpoint);
                continue;
            }

            spawnpointArray.Add(new ProbabilityObject<string, Spawnpoint>(spawnpoint.Template.Id, spawnpoint.Probability ?? 0, spawnpoint));
        }

        // Select a number of spawn points to add loot to
        // Add ALL loose loot with 100% chance to pool
        List<Spawnpoint> chosenSpawnpoints = [];
        chosenSpawnpoints.AddRange(guaranteedLoosePoints);

        var randomSpawnpointCount = desiredSpawnpointCount - chosenSpawnpoints.Count;
        // Only draw random spawn points if needed
        if (randomSpawnpointCount > 0 && spawnpointArray.Count > 0)
        {
            // Add randomly chosen spawn points
            foreach (var si in spawnpointArray.Draw((int)randomSpawnpointCount, false))
            {
                chosenSpawnpoints.Add(spawnpointArray.Data(si));
            }
        }

        // Filter out duplicate locationIds // prob can be done better
        chosenSpawnpoints = chosenSpawnpoints.GroupBy(spawnpoint => spawnpoint.LocationId).Select(group => group.First()).ToList();

        // Do we have enough items in pool to fulfill requirement
        var tooManySpawnPointsRequested = desiredSpawnpointCount - chosenSpawnpoints.Count > 0;
        if (tooManySpawnPointsRequested)
        {
            _logger.Debug(
                _localisationService.GetText(
                    "location-spawn_point_count_requested_vs_found",
                    new
                    {
                        requested = desiredSpawnpointCount + guaranteedLoosePoints.Count,
                        found = chosenSpawnpoints.Count,
                        mapName = locationName,
                    }
                )
            );
        }

        // Iterate over spawnpoints
        var seasonalEventActive = _seasonalEventService.SeasonalEventEnabled();
        var seasonalItemTplBlacklist = _seasonalEventService.GetInactiveSeasonalEventItems();
        foreach (var spawnPoint in chosenSpawnpoints)
        {
            // Spawnpoint is invalid, skip it
            if (spawnPoint.Template is null)
            {
                _logger.Warning(
                    _localisationService.GetText("location-missing_dynamic_template", spawnPoint.LocationId)
                );

                continue;
            }

            // Ensure no blacklisted lootable items are in pool
            spawnPoint.Template.Items = spawnPoint.Template.Items.Where(
                    (item) => !_itemFilterService.IsLootableItemBlacklisted(item.Template)
                )
                .ToList();

            // Ensure no seasonal items are in pool if not in-season
            if (!seasonalEventActive)
            {
                spawnPoint.Template.Items = spawnPoint.Template.Items.Where(
                        (item) => !seasonalItemTplBlacklist.Contains(item.Template)
                    )
                    .ToList();
            }

            // Spawn point has no items after filtering, skip
            if (spawnPoint.Template.Items is null || spawnPoint.Template.Items.Count == 0)
            {
                _logger.Warning(
                    _localisationService.GetText("location-spawnpoint_missing_items", spawnPoint.Template.Id)
                );

                continue;
            }

            // Get an array of allowed IDs after above filtering has occured
            var validItemIds = spawnPoint.Template.Items.Select((item) => item.Id).ToList();

            // Construct container to hold above filtered items, letting us pick an item for the spot
            var itemArray = new ProbabilityObjectArray<ProbabilityObject<string, double?>, string, double?>(_mathUtil, _cloner, []);
            foreach (var itemDist in spawnPoint.ItemDistribution)
            {
                if (!validItemIds.Contains(itemDist.ComposedKey.Key))
                {
                    continue;
                }

                itemArray.Add(new ProbabilityObject<string, double?>(itemDist.ComposedKey.Key, itemDist.RelativeProbability ?? 0, null));
            }

            if (itemArray.Count == 0)
            {
                _logger.Warning(
                    _localisationService.GetText("location-loot_pool_is_empty_skipping", spawnPoint.Template.Id)
                );

                continue;
            }

            // Draw a random item from spawn points possible items
            var chosenComposedKey = itemArray.Draw(1).FirstOrDefault();
            var createItemResult = CreateDynamicLootItem(
                chosenComposedKey,
                spawnPoint.Template.Items,
                staticAmmoDist
            );

            // Root id can change when generating a weapon, ensure ids match
            spawnPoint.Template.Root = createItemResult.Items.FirstOrDefault().Id;

            // Overwrite entire pool with chosen item
            spawnPoint.Template.Items = createItemResult.Items;

            loot.Add(spawnPoint.Template);
        }

        return loot;
    }

    /// <summary>
    ///     Add forced spawn point loot into loot parameter list
    /// </summary>
    /// <param name="lootLocationTemplates">List to add forced loot spawn locations to</param>
    /// <param name="forcedSpawnPoints">Forced loot locations that must be added</param>
    /// <param name="locationName">Name of map currently having force loot created for</param>
    protected void AddForcedLoot(List<SpawnpointTemplate> lootLocationTemplates,
        List<Spawnpoint> forcedSpawnPoints, string locationName,
        Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist)
    {
        var lootToForceSingleAmountOnMap = _locationConfig.ForcedLootSingleSpawnById.GetValueOrDefault(locationName);
        if (lootToForceSingleAmountOnMap is not null)
        {
            // Process loot items defined as requiring only 1 spawn position as they appear in multiple positions on the map
            foreach (var itemTpl in lootToForceSingleAmountOnMap)
            {
                // Get all spawn positions for item tpl in forced loot array
                var items = forcedSpawnPoints.Where(
                    (forcedSpawnPoint) => forcedSpawnPoint.Template.Items[0].Template == itemTpl
                );
                if (items is null || !items.Any())
                {
                    _logger.Debug($"Unable to adjust loot item {itemTpl} as it does not exist inside {locationName} forced loot.");
                    continue;
                }

                // Create probability array of all spawn positions for this spawn id
                var spawnpointArray = new ProbabilityObjectArray<ProbabilityObject<string, Spawnpoint>, string, Spawnpoint>(_mathUtil, _cloner, []);
                foreach (var si in items)
                {
                    // use locationId as template.Id is the same across all items
                    spawnpointArray.Add(new ProbabilityObject<string, Spawnpoint>(si.LocationId, si.Probability ?? 0, si));
                }

                // Choose 1 out of all found spawn positions for spawn id and add to loot array
                foreach (var spawnPointLocationId in spawnpointArray.Draw(1, false))
                {
                    var itemToAdd = items.FirstOrDefault((item) => item.LocationId == spawnPointLocationId);
                    var lootItem = itemToAdd?.Template;
                    if (lootItem is null)
                    {
                        _logger.Warning($"Item with spawn point id {spawnPointLocationId} could not be found, skipping");
                        continue;
                    }

                    var createItemResult = CreateDynamicLootItem(
                        lootItem.Items.FirstOrDefault().Id,
                        lootItem.Items,
                        staticAmmoDist
                    );

                    // Update root ID with the dynamically generated ID
                    lootItem.Root = createItemResult.Items.FirstOrDefault().Id;
                    lootItem.Items = createItemResult.Items;
                    lootLocationTemplates.Add(lootItem);
                }
            }
        }

        var seasonalEventActive = _seasonalEventService.SeasonalEventEnabled();
        var seasonalItemTplBlacklist = _seasonalEventService.GetInactiveSeasonalEventItems();

        // Add remaining forced loot to array
        foreach (var forcedLootLocation in forcedSpawnPoints)
        {
            var firstLootItemTpl = forcedLootLocation.Template.Items.FirstOrDefault().Template;

            // Skip spawn positions processed already
            if (lootToForceSingleAmountOnMap?.Contains(firstLootItemTpl) ?? false)
            {
                continue;
            }

            // Skip adding seasonal items when seasonal event is not active
            if (!seasonalEventActive && seasonalItemTplBlacklist.Contains(firstLootItemTpl))
            {
                continue;
            }

            var locationTemplateToAdd = forcedLootLocation.Template;
            var createItemResult = CreateDynamicLootItem(
                locationTemplateToAdd.Items.FirstOrDefault().Id,
                forcedLootLocation.Template.Items,
                staticAmmoDist
            );

            // Update root ID with the dynamically generated ID
            forcedLootLocation.Template.Root = createItemResult.Items.FirstOrDefault().Id;
            forcedLootLocation.Template.Items = createItemResult.Items;

            // Push forced location into array as long as it doesnt exist already
            var existingLocation = lootLocationTemplates.Any(
                (spawnPoint) => spawnPoint.Id == locationTemplateToAdd.Id
            );
            if (!existingLocation)
            {
                lootLocationTemplates.Add(locationTemplateToAdd);
            }
            else
            {
                _logger.Debug(
                    $"Attempted to add a forced loot location with Id: {locationTemplateToAdd.Id} to map {locationName} that already has that id in use, skipping"
                );
            }
        }
    }

    private ContainerItem CreateDynamicLootItem(string? chosenComposedKey, List<Item> items, Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist)
    {
        var chosenItem = items.FirstOrDefault((item) => item.Id == chosenComposedKey);
        var chosenTpl = chosenItem?.Template;
        if (chosenTpl is null) {
            throw new Exception($"Item for tpl {chosenComposedKey} was not found in the spawn point");
        }
        var itemTemplate = _itemHelper.GetItem(chosenTpl).Value;
        if (itemTemplate is null) {
            _logger.Error($"Item tpl: {chosenTpl} cannot be found in database");
        }

        // Item array to return
        List<Item> itemWithMods = [];

        // Money/Ammo - don't rely on items in spawnPoint.template.Items so we can randomise it ourselves
        if (_itemHelper.IsOfBaseclasses(chosenTpl, [BaseClasses.MONEY, BaseClasses.AMMO])) {
            var stackCount =
                itemTemplate.Properties.StackMaxSize == 1
                    ? 1
                    : _randomUtil.GetInt((int)itemTemplate.Properties.StackMinRandom, (int)itemTemplate.Properties.StackMaxRandom);

            itemWithMods.Add(new Item {
                Id = _hashUtil.Generate(),
                Template = chosenTpl,
                Upd = new Upd { StackObjectsCount = stackCount }
            });
        } else if (_itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.AMMO_BOX)) {
            // Fill with cartridges
            List<Item> ammoBoxItem = [ new Item { Id = _hashUtil.Generate(), Template = chosenTpl }];
            _itemHelper.AddCartridgesToAmmoBox(ammoBoxItem, itemTemplate);
            itemWithMods.AddRange(ammoBoxItem);
        } else if (_itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.MAGAZINE)) {
            // Create array with just magazine
            List<Item> magazineItem = [new Item { Id = _hashUtil.Generate(), Template = chosenTpl }];

            if (_randomUtil.GetChance100(_locationConfig.StaticMagazineLootHasAmmoChancePercent)) {
                // Add randomised amount of cartridges
                _itemHelper.FillMagazineWithRandomCartridge(
                    magazineItem,
                    itemTemplate, // Magazine template
                    staticAmmoDist,
                    null,
                    _locationConfig.MinFillLooseMagazinePercent / 100
                );
            }

            itemWithMods.AddRange(magazineItem);
        } else {
            // Also used by armors to get child mods
            // Get item + children and add into array we return
            var itemWithChildren = _itemHelper.FindAndReturnChildrenAsItems(items, chosenItem.Id);

            // Ensure all IDs are unique
            itemWithChildren = _itemHelper.ReplaceIDs(_cloner.Clone(itemWithChildren));

            if (_locationConfig.TplsToStripChildItemsFrom.Contains(chosenItem.Template)) {
                // Strip children from parent before adding
                itemWithChildren = [itemWithChildren[0]];
            }

            itemWithMods.AddRange(itemWithChildren);
        }

        // Get inventory size of item
        var size = _itemHelper.GetItemSize(itemWithMods, itemWithMods[0].Id);

        return new ContainerItem { Items = itemWithMods, Width = size.Width, Height = size.Height };
    }

    private double GetLooseLootMultiplerForLocation(string location)
    {
        return _locationConfig.LooseLootMultiplier[location];
    }
    
    protected double getStaticLootMultiplerForLocation(string location) {
        return _locationConfig.StaticLootMultiplier[location];
    }


    // TODO: rewrite, BIG yikes
    protected ContainerItem? CreateStaticLootItem(
        string chosenTpl,
        Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist,
        string? parentId = null)
    {
        var itemTemplate = _itemHelper.GetItem(chosenTpl).Value;
        if (itemTemplate.Properties is null)
        {
            _logger.Error($"Unable to process item: ${{chosenTpl}}. it lacks _props");

            return null;
        }

        var width = itemTemplate.Properties.Width;
        var height = itemTemplate.Properties.Height;
        List<Item> items = [new Item { Id = _hashUtil.Generate(), Template = chosenTpl }];
        var rootItem = items.FirstOrDefault();

        // Use passed in parentId as override for new item
        if (!string.IsNullOrEmpty(parentId))
        {
            rootItem.ParentId = parentId;
        }

        if (
            _itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.MONEY) ||
            _itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.AMMO)
        )
        {
            // Edge case - some ammos e.g. flares or M406 grenades shouldn't be stacked
            var stackCount = itemTemplate.Properties.StackMaxSize == 1
                ? 1
                : _randomUtil.GetInt((int)(itemTemplate.Properties.StackMinRandom), (int)(itemTemplate.Properties.StackMaxRandom));

            rootItem.Upd = new Upd { StackObjectsCount = stackCount };
        }
        // No spawn point, use default template
        else if (_itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.WEAPON))
        {
            List<Item> children = [];
            var defaultPreset = _cloner.Clone(_presetHelper.GetDefaultPreset(chosenTpl));
            if (defaultPreset?.Items is not null)
            {
                try
                {
                    children = _itemHelper.ReparentItemAndChildren(defaultPreset.Items[0], defaultPreset.Items);
                }
                catch (Exception e)
                {
                    // this item already broke it once without being reproducible tpl = "5839a40f24597726f856b511"; AKS-74UB Default
                    // 5ea03f7400685063ec28bfa8 // ppsh default
                    // 5ba26383d4351e00334c93d9 //mp7_devgru
                    _logger.Error(
                        _localisationService.GetText(
                            "location-preset_not_found",
                            new
                            {
                                tpl = chosenTpl,
                                defaultId = defaultPreset.Id,
                                defaultName = defaultPreset.Name,
                                parentId,
                            }
                        )
                    );

                    throw;
                }
            }
            else
            {
                // RSP30 (62178be9d0050232da3485d9/624c0b3340357b5f566e8766/6217726288ed9f0845317459) doesn't have any default presets and kills this code below as it has no chidren to reparent
                _logger.Debug($"createStaticLootItem() No preset found for weapon: {chosenTpl}");
            }

            rootItem = items[0];
            if (rootItem is null)
            {
                _logger.Error(
                    _localisationService.GetText(
                        "location-missing_root_item",
                        new
                        {
                            tpl = chosenTpl,
                            parentId,
                        }
                    )
                );

                throw new Exception(_localisationService.GetText("location-critical_error_see_log"));
            }

            try
            {
                if (children?.Count > 0)
                {
                    items = _itemHelper.ReparentItemAndChildren(rootItem, children);
                }
            }
            catch (Exception e)
            {
                _logger.Error(
                    _localisationService.GetText(
                        "location-unable_to_reparent_item",
                        new
                        {
                            tpl = chosenTpl,
                            parentId = parentId,
                        }
                    )
                );

                throw;
            }

            // Here we should use generalized BotGenerators functions e.g. fillExistingMagazines in the future since
            // it can handle revolver ammo (it's not restructured to be used here yet.)
            // General: Make a WeaponController for Ragfair preset stuff and the generating weapons and ammo stuff from
            // BotGenerator
            var magazine = items.FirstOrDefault(item => item.SlotId == "mod_magazine");
            // some weapon presets come without magazine; only fill the mag if it exists
            if (magazine is not null)
            {
                var magTemplate = _itemHelper.GetItem(magazine.Template).Value;
                var weaponTemplate = _itemHelper.GetItem(chosenTpl).Value;

                // Create array with just magazine
                var defaultWeapon = _itemHelper.GetItem(rootItem.Template).Value;
                List<Item> magazineWithCartridges = [magazine];
                _itemHelper.FillMagazineWithRandomCartridge(
                    magazineWithCartridges,
                    magTemplate,
                    staticAmmoDist,
                    weaponTemplate.Properties.AmmoCaliber,
                    0.25,
                    defaultWeapon.Properties.DefAmmo,
                    defaultWeapon
                );

                // Replace existing magazine with above array
                items.Remove(magazine);
                items.AddRange(magazineWithCartridges);
            }

            var size = _itemHelper.GetItemSize(items, rootItem.Id);
            width = size.Width;
            height = size.Height;
        }
        // No spawnpoint to fall back on, generate manually
        else if (_itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.AMMO_BOX))
        {
            _itemHelper.AddCartridgesToAmmoBox(items, itemTemplate);
        }
        else if (_itemHelper.IsOfBaseclass(chosenTpl, BaseClasses.MAGAZINE))
        {
            if (_randomUtil.GetChance100(_locationConfig.MagazineLootHasAmmoChancePercent))
            {
                // Create array with just magazine
                List<Item> magazineWithCartridges = [rootItem];
                _itemHelper.FillMagazineWithRandomCartridge(
                    magazineWithCartridges,
                    itemTemplate,
                    staticAmmoDist,
                    null,
                    _locationConfig.MinFillStaticMagazinePercent / 100
                );

                // Replace existing magazine with above array
                items.Remove(rootItem);
                items.AddRange(magazineWithCartridges);
            }
        }
        else if (_itemHelper.ArmorItemCanHoldMods(chosenTpl))
        {
            var defaultPreset = _presetHelper.GetDefaultPreset(chosenTpl);
            if (defaultPreset is not null)
            {
                List<Item> presetAndMods = _itemHelper.ReplaceIDs(_cloner.Clone(defaultPreset.Items));
                _itemHelper.RemapRootItemId(presetAndMods);

                // Use original items parentId otherwise item doesnt get added to container correctly
                presetAndMods[0].ParentId = rootItem.ParentId;
                items = presetAndMods;
            }
            else
            {
                // We make base item above, at start of function, no need to do it here
                if ((itemTemplate.Properties.Slots?.Count ?? 0) > 0)
                {
                    items = _itemHelper.AddChildSlotItems(
                        items,
                        itemTemplate,
                        _locationConfig.EquipmentLootSettings.ModSpawnChancePercent
                    );
                }
            }
        }

        return new ContainerItem { Items = items, Width = width, Height = height };
    }
}

public class ContainerGroupCount
{
    [JsonPropertyName("containerIdsWithProbability")]
    public Dictionary<string, double>? ContainerIdsWithProbability { get; set; }

    [JsonPropertyName("chosenCount")]
    public double? ChosenCount { get; set; }
}

public class ContainerItem
{
    [JsonPropertyName("items")]
    public List<Item>? Items { get; set; }

    [JsonPropertyName("width")]
    public double? Width { get; set; }

    [JsonPropertyName("height")]
    public double? Height { get; set; }
}