using LootDumpProcessor.Logger;
using LootDumpProcessor.Model;
using LootDumpProcessor.Model.Output;
using LootDumpProcessor.Model.Output.LooseLoot;
using LootDumpProcessor.Model.Processing;
using LootDumpProcessor.Storage;
using LootDumpProcessor.Storage.Collections;
using LootDumpProcessor.Utils;
using NumSharp;

namespace LootDumpProcessor.Process.Processor;

public static class LooseLootProcessor
{
    public static PreProcessedLooseLoot PreProcessLooseLoot(List<Template> looseloot)
    {
        var looseloot_ci = new PreProcessedLooseLoot
        {
            Counts = new Dictionary<string, int>()
        };
        var temporalItemProperties = new SubdivisionedKeyableDictionary<string, List<Template>>();
        looseloot_ci.ItemProperties = (AbstractKey)temporalItemProperties.GetKey();
        looseloot_ci.MapSpawnpointCount = looseloot.Count;
        var uniqueIds = new Dictionary<string, object>();
        // sometimes the rotation changes very slightly in the dumps for the same location / rotation spawnpoint
        // use rounding to make sure it is not generated to two spawnpoint

        foreach (var looseLootTemplate in looseloot)
        {
            // the bsg ids are insane.
            // Sometimes the last 7 digits vary but they spawn the same item at the same position
            // e.g. for the quest item "60a3b65c27adf161da7b6e14" at "loot_bunker_quest (3)555192"
            // so the first approach was to remove the last digits.
            // We then saw, that sometimes when the last digits differ for the same string, also the position
            // differs.
            // We decided to group over the position/rotation/useGravity since they make out a distinct spot
            var saneId = looseLootTemplate.GetSaneId();
            if (!uniqueIds.ContainsKey(saneId))
            {
                uniqueIds[saneId] = looseLootTemplate.Id;
                if (looseloot_ci.Counts.ContainsKey(saneId))
                    looseloot_ci.Counts[saneId]++;
                else
                    looseloot_ci.Counts[saneId] = 1;
            }

            if (!temporalItemProperties.TryGetValue(saneId, out var templates))
            {
                templates = new FlatKeyableList<Template>();
                temporalItemProperties.Add(saneId, templates);
            }

            templates.Add(looseLootTemplate);
        }

        DataStorageFactory.GetInstance().Store(temporalItemProperties);
        return looseloot_ci;
    }

    public static Dictionary<string, LooseLootRoot> CreateLooseLootDistribution(
        Dictionary<string, int> map_counts,
        Dictionary<string, IKey> looseloot_counts
    )
    {
        var forcedConfidence = LootDumpProcessorContext.GetConfig().ProcessorConfig.SpawnPointToleranceForForced / 100;
        var probabilities = new Dictionary<string, Dictionary<string, double>>();
        var looseLootDistribution = new Dictionary<string, LooseLootRoot>();
        foreach (var _tup_1 in map_counts)
        {
            var mapName = _tup_1.Key;
            var mapCount = _tup_1.Value;
            probabilities[mapName] = new Dictionary<string, double>();
            var looseLootCounts = DataStorageFactory.GetInstance().GetItem<LooseLootCounts>(looseloot_counts[mapName]);

            var counts = DataStorageFactory.GetInstance()
                .GetItem<FlatKeyableDictionary<string, int>>(looseLootCounts.Counts);
            foreach (var (idi, cnt) in counts)
            {
                probabilities[mapName][idi] = (double)((decimal)cnt / mapCount);
            }

            // No longer used, dispose
            counts = null;

            // we want to cleanup the data, so we calculate the mean for the values we get raw
            // For whatever reason, we sometimes get dumps that have A LOT more loose loot point than 
            // the average
            var values = looseLootCounts.MapSpawnpointCount.Select(Convert.ToDouble);
            var initialMean = np.mean(np.array(values)).ToArray<double>().First();
            var looseLootCountTolerancePercentage = LootDumpProcessorContext.GetConfig().ProcessorConfig.LooseLootCountTolerancePercentage / 100;
            // We calculate here a high point to check, anything above this value will be ignored
            // The data that was inside those loose loot points still counts for them though!
            var high = initialMean * (1 + looseLootCountTolerancePercentage);
            looseLootCounts.MapSpawnpointCount = looseLootCounts.MapSpawnpointCount.Where(v => v <= high).ToList();

            looseLootDistribution[mapName] = new LooseLootRoot
            {
                SpawnPointCount = new SpawnPointCount
                {
                    Mean = np.mean(np.array(looseLootCounts.MapSpawnpointCount)),
                    Std = np.std(np.array(looseLootCounts.MapSpawnpointCount))
                },
                SpawnPointsForced = new List<SpawnPointsForced>(),
                SpawnPoints = new List<SpawnPoint>()
            };

            var itemProperties = DataStorageFactory.GetInstance()
                .GetItem<FlatKeyableDictionary<string, IKey>>(looseLootCounts.ItemProperties);
            foreach (var (spawnPoint, itemList) in itemProperties)
            {
                var itemsCounts = new Dictionary<ComposedKey, int>();

                var savedItemProperties = DataStorageFactory.GetInstance().GetItem<FlatKeyableList<Template>>(itemList);
                foreach (var savedTemplateProperties in savedItemProperties)
                {
                    var key = new ComposedKey(savedTemplateProperties);
                    if (itemsCounts.ContainsKey(key))
                        itemsCounts[key] += 1;
                    else
                        itemsCounts[key] = 1;
                }

                // Group by arguments to create possible positions / rotations per spawnpoint

                // check if grouping is unique
                var itemListSorted = savedItemProperties.Select(template => (template.GetSaneId(), template))
                    .GroupBy(g => g.Item1).ToList();

                if (itemListSorted.Count > 1)
                {
                    throw new Exception("More than one saneKey found");
                }

                var spawnPoints = itemListSorted.First().Select(v => v.template).ToList();
                var locationId = spawnPoints[0].GetLocationId();
                var template = ProcessorUtil.Copy(spawnPoints[0]);
                //template.Root = null; // Why do we do this, not null in bsg data
                var itemDistribution = itemsCounts.Select(kv => new ItemDistribution
                {
                    ComposedKey = kv.Key,
                    RelativeProbability = kv.Value
                }).ToList();

                // If any of the items is a quest item or forced loose loot items, or the item normally appreas 99.5%
                // Only add position to forced loot if it has only 1 item in the array.
                if (itemDistribution.Count == 1 && itemDistribution.Any(item =>
                        LootDumpProcessorContext.GetTarkovItems().IsQuestItem(item.ComposedKey?.FirstItem?.Tpl) ||
                        LootDumpProcessorContext.GetForcedLooseItems()[mapName].Contains(item.ComposedKey?.FirstItem?.Tpl))
                   )
                {
                    var spawnPointToAdd = new SpawnPointsForced
                    {
                        LocationId = locationId,
                        Probability = probabilities[mapName][spawnPoint],
                        Template = template
                    };
                    looseLootDistribution[mapName].SpawnPointsForced.Add(spawnPointToAdd);
                }
                else if (probabilities[mapName][spawnPoint] > forcedConfidence)
                {
                    var spawnPointToAdd = new SpawnPointsForced
                    {
                        LocationId = locationId,
                        Probability = probabilities[mapName][spawnPoint],
                        Template = template
                    };
                    looseLootDistribution[mapName].SpawnPointsForced.Add(spawnPointToAdd);
                    if (LoggerFactory.GetInstance().CanBeLogged(LogLevel.Warning))
                        LoggerFactory.GetInstance().Log(
                            $"Item: {template.Id} has > {LootDumpProcessorContext.GetConfig().ProcessorConfig.SpawnPointToleranceForForced}% spawn chance in spawn point: {spawnPointToAdd.LocationId} but isn't in forced loot, adding to forced",
                            LogLevel.Warning
                        );
                }
                else // Normal spawn point, add to non-forced spawnpoint array
                {
                    var spawnPointToAdd = new SpawnPoint
                    {
                        LocationId = locationId,
                        Probability = probabilities[mapName][spawnPoint],
                        Template = template,
                        ItemDistribution = itemDistribution
                    };
                    
                    template.Items = new List<Item>();

                    var group = spawnPoints.GroupBy(template => new ComposedKey(template))
                        .ToDictionary(g => g.Key, g => g.ToList());
                    foreach (var distribution in itemDistribution)
                    {
                        if (group.TryGetValue(distribution.ComposedKey, out var items))
                        {
                            // We need to reparent the IDs to match the composed key ID
                            var itemDistributionItemList = items.First().Items;
                            // Find the item with no parent id, this is essentially the "Root" of the actual item
                            var firstItemInTemplate =
                                itemDistributionItemList.Find(i => string.IsNullOrEmpty(i.ParentId));
                            // Save the original ID reference, we need to replace it on child items
                            var originalId = firstItemInTemplate.Id;
                            // Put the composed key instead
                            firstItemInTemplate.Id = distribution.ComposedKey.Key;
                            // Reparent any items with the original id on it
                            itemDistributionItemList.Where(i => i.ParentId == originalId)
                                .ToList()
                                .ForEach(i => i.ParentId = firstItemInTemplate.Id);
                            
                            template.Items.AddRange(itemDistributionItemList);
                        }
                        else
                        {
                            if (LoggerFactory.GetInstance().CanBeLogged(LogLevel.Error))
                                LoggerFactory.GetInstance().Log(
                                    $"Item template {distribution.ComposedKey?.FirstItem?.Tpl} was on loose loot distribution for spawn point {template.Id} but the spawn points didnt contain a template matching it.",
                                    LogLevel.Error
                                );
                        }
                    }

                    looseLootDistribution[mapName].SpawnPoints.Add(spawnPointToAdd);
                }
            }

            // # Test for duplicate position
            // # we removed most of them by "rounding away" the jitter in rotation,
            // # there are still a few duplicate locations with distinct difference in rotation left though
            // group_fun = lambda x: (
            //     x["template"]["Position"]["x"],
            //     x["template"]["Position"]["y"],
            //     x["template"]["Position"]["z"],
            // )
            // test = sorted(loose_loot_distribution[mi]["spawnpoints"], key=group_fun)
            // test_grouped = groupby(test, group_fun)
            // test_len = []
            // for k, g in test_grouped:
            //     gl = list(g)
            //     test_len.append(len(gl))
            //     if len(gl) > 1:
            //         print(gl)
            //
            // print(mi, np.unique(test_len, return_counts=True))
            looseLootDistribution[mapName].SpawnPoints =
                looseLootDistribution[mapName].SpawnPoints.OrderBy(x => x.Template.Id).ToList();
            // Cross check with forced loot in dumps vs items defined in forced_loose.yaml
            var forcedTplsInConfig = new HashSet<string>(
                (from forceditem in LootDumpProcessorContext.GetForcedLooseItems()[mapName]
                    select forceditem).ToList());
            var forcedTplsFound = new HashSet<string>(
                (from forceditem in looseLootDistribution[mapName].SpawnPointsForced
                    select forceditem.Template.Items[0].Tpl).ToList());

            // All the tpls that are defined in the forced_loose.yaml for this map that are not found as forced
            foreach (var itemTpl in forcedTplsInConfig)
            {
                if (!forcedTplsFound.Contains(itemTpl))
                {
                    if (LoggerFactory.GetInstance().CanBeLogged(LogLevel.Error))
                        LoggerFactory.GetInstance().Log(
                            $"Expected item: {itemTpl} defined in forced_loose.yaml config not found in forced loot",
                            LogLevel.Error
                        );
                }
            }

            // All the tpls that are found as forced in output file but not in the forced_loose.yaml config
            foreach (var itemTpl in forcedTplsFound)
            {
                if (!forcedTplsInConfig.Contains(itemTpl))
                {
                    if (LoggerFactory.GetInstance().CanBeLogged(LogLevel.Warning))
                        LoggerFactory.GetInstance().Log(
                            $"Map: {mapName} Item: {itemTpl} not defined in forced_loose.yaml config but was flagged as forced by code",
                            LogLevel.Warning
                        );
                }
            }
        }

        return looseLootDistribution;
    }
}