using System;
using System.Collections.Generic;
using GeometryTD.CustomUtility;
using GeometryTD.Definition;
using UnityEngine;

namespace GeometryTD.UI
{
    public partial class RepoFormController
    {
        private RepoFormContext BuildContext(RepoFormRawData rawData)
        {
            _itemClickActionMap.Clear();
            _itemDescSeedMap.Clear();
            _compAreaTowerIds.Clear();
            if (rawData?.Inventory == null)
            {
                _participantTowerIds.Clear();
                return null;
            }

            Dictionary<long, MuzzleCompItemData> muzzleMap = BuildComponentMap(rawData.Inventory.MuzzleComponents);
            Dictionary<long, BearingCompItemData> bearingMap = BuildComponentMap(rawData.Inventory.BearingComponents);
            Dictionary<long, BaseCompItemData> baseMap = BuildComponentMap(rawData.Inventory.BaseComponents);
            Dictionary<long, TowerItemData> towerMap = BuildTowerMap(rawData.Inventory.Towers);
            List<RepoItemContext> componentItems = new List<RepoItemContext>();
            List<TowerRepoItemContext> towerItems = new List<TowerRepoItemContext>();

            if (rawData.Inventory.Towers != null)
            {
                foreach (var tower in rawData.Inventory.Towers)
                {
                    if (tower == null)
                    {
                        continue;
                    }

                    TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
                        RepoItemClickActionType.OpenDetail, true);
                    AddTowerItemContext(towerItems, towerContext);
                    AddItemDescSeed(
                        tower.InstanceId,
                        tower.Name,
                        "Tower",
                        ItemDescUtility.BuildTowerDesc(tower, muzzleMap, bearingMap, baseMap) ?? string.Empty,
                        tower.Stats?.Tags,
                        tower.Stats?.TagRuntimes);
                }
            }

            if (rawData.Inventory.MuzzleComponents != null)
            {
                foreach (var item in rawData.Inventory.MuzzleComponents)
                {
                    if (item == null || item.IsAssembledIntoTower)
                    {
                        continue;
                    }

                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
                        EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Muzzle,
                        IconAreaContext = BuildIconAreaContext(item)
                    };
                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
                        BuildComponentTypeText(item.SlotType),
                        ItemDescUtility.BuildMuzzleDesc(item) ?? string.Empty,
                        item.Tags,
                        null);
                }
            }

            if (rawData.Inventory.BearingComponents != null)
            {
                foreach (BearingCompItemData item in rawData.Inventory.BearingComponents)
                {
                    if (item == null || item.IsAssembledIntoTower)
                    {
                        continue;
                    }

                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
                        EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Bearing,
                        IconAreaContext = BuildIconAreaContext(item)
                    };
                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
                        BuildComponentTypeText(item.SlotType),
                        ItemDescUtility.BuildBearingDesc(item) ?? string.Empty,
                        item.Tags,
                        null);
                }
            }

            if (rawData.Inventory.BaseComponents != null)
            {
                foreach (BaseCompItemData item in rawData.Inventory.BaseComponents)
                {
                    if (item == null || item.IsAssembledIntoTower)
                    {
                        continue;
                    }

                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
                        EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Base,
                        IconAreaContext = BuildIconAreaContext(item)
                    };
                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
                        BuildComponentTypeText(item.SlotType),
                        ItemDescUtility.BuildBaseDesc(item) ?? string.Empty,
                        item.Tags,
                        null);
                }
            }

            ParticipantAreaContext participantAreaContext =
                BuildParticipantAreaContext(rawData.Inventory, towerMap, muzzleMap, bearingMap, baseMap);

            return new RepoFormContext
            {
                GoldText = $"金币: {rawData.Inventory.Gold}",
                CombineAreaContext = new CombineAreaContext(),
                CompAreaContext = new CompAreaContext
                {
                    ComponentItems = componentItems.ToArray(),
                    TowerItems = towerItems.ToArray()
                },
                ParticipantAreaContext = participantAreaContext
            };
        }

        private void AddComponentItemContext(List<RepoItemContext> items, RepoItemContext itemContext)
        {
            if (itemContext == null)
            {
                return;
            }

            items.Add(itemContext);
            _itemClickActionMap[itemContext.InstanceId] = itemContext.ClickActionType;
        }

        private void AddTowerItemContext(List<TowerRepoItemContext> items, TowerRepoItemContext itemContext)
        {
            if (itemContext == null)
            {
                return;
            }

            items.Add(itemContext);
            _itemClickActionMap[itemContext.InstanceId] = itemContext.ClickActionType;
            _compAreaTowerIds.Add(itemContext.InstanceId);
        }

        private void AddItemDescSeed(
            long itemId,
            string title,
            string typeText,
            string description,
            TagType[] tags,
            TagRuntimeData[] tagRuntimes)
        {
            if (itemId <= 0)
            {
                return;
            }

            _itemDescSeedMap[itemId] = new ItemDescSeed
            {
                Title = string.IsNullOrWhiteSpace(title) ? $"Item {itemId}" : title,
                TypeText = typeText ?? string.Empty,
                Description = description ?? string.Empty,
                Tags = tags,
                TagRuntimes = tagRuntimes
            };
        }

        private static string BuildComponentTypeText(TowerCompSlotType slotType)
        {
            return slotType switch
            {
                TowerCompSlotType.Muzzle => "Muzzle Component",
                TowerCompSlotType.Bearing => "Bearing Component",
                TowerCompSlotType.Base => "Base Component",
                TowerCompSlotType.Accessory => "Accessory",
                _ => "Component"
            };
        }

        private static Dictionary<long, TComp> BuildComponentMap<TComp>(IReadOnlyList<TComp> items)
            where TComp : TowerCompItemData
        {
            Dictionary<long, TComp> map = new Dictionary<long, TComp>();
            if (items == null)
            {
                return map;
            }

            foreach (var item in items)
            {
                if (item == null || item.InstanceId <= 0)
                {
                    continue;
                }

                map[item.InstanceId] = item;
            }

            return map;
        }

        private static Dictionary<long, TowerItemData> BuildTowerMap(IReadOnlyList<TowerItemData> towers)
        {
            Dictionary<long, TowerItemData> map = new Dictionary<long, TowerItemData>();
            if (towers == null)
            {
                return map;
            }

            foreach (var tower in towers)
            {
                if (tower == null || tower.InstanceId <= 0)
                {
                    continue;
                }

                map[tower.InstanceId] = tower;
            }

            return map;
        }

        private ParticipantAreaContext BuildParticipantAreaContext(
            BackpackInventoryData inventory,
            IReadOnlyDictionary<long, TowerItemData> towerMap,
            IReadOnlyDictionary<long, MuzzleCompItemData> muzzleMap,
            IReadOnlyDictionary<long, BearingCompItemData> bearingMap,
            IReadOnlyDictionary<long, BaseCompItemData> baseMap)
        {
            _participantTowerIds.Clear();
            List<TowerRepoItemContext> participantItems = new List<TowerRepoItemContext>();
            if (inventory?.ParticipantTowerInstanceIds != null && towerMap != null)
            {
                foreach (var towerId in inventory.ParticipantTowerInstanceIds)
                {
                    if (towerId <= 0)
                    {
                        continue;
                    }

                    if (!towerMap.TryGetValue(towerId, out TowerItemData tower) || tower == null)
                    {
                        continue;
                    }

                    if (!_participantTowerIds.Add(towerId))
                    {
                        continue;
                    }

                    TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
                        RepoItemClickActionType.RemoveParticipant, false);
                    if (towerContext != null)
                    {
                        participantItems.Add(towerContext);
                        _itemClickActionMap[towerContext.InstanceId] = towerContext.ClickActionType;
                    }
                }
            }

            return new ParticipantAreaContext
            {
                TowerItems = participantItems.ToArray(),
                MaxCount = MaxParticipantCount
            };
        }

        private void ApplyParticipantSelection()
        {
            if (Form == null || _compAreaTowerIds.Count <= 0)
            {
                return;
            }

            foreach (long towerId in _compAreaTowerIds)
            {
                Form.SetRepoItemSelected(towerId, _participantTowerIds.Contains(towerId));
            }
        }

        private void RefreshParticipantAreaOnly()
        {
            if (_useCase == null || Form == null)
            {
                return;
            }

            RepoFormContext latestContext = BuildContext(_useCase.CreateInitialModel());
            if (latestContext?.ParticipantAreaContext == null)
            {
                return;
            }

            Form.RefreshGoldText(latestContext.GoldText);
            Form.RefreshParticipantArea(latestContext.ParticipantAreaContext);
            ApplyParticipantSelection();
        }

        private static TowerRepoItemContext BuildTowerRepoItemContext(
            TowerItemData tower,
            IReadOnlyDictionary<long, MuzzleCompItemData> muzzleMap,
            IReadOnlyDictionary<long, BearingCompItemData> bearingMap,
            IReadOnlyDictionary<long, BaseCompItemData> baseMap,
            RepoItemClickActionType clickActionType,
            bool canDrag)
        {
            if (tower == null)
            {
                return null;
            }

            return new TowerRepoItemContext
            {
                InstanceId = tower.InstanceId,
                CanDrag = canDrag,
                EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
                ClickActionType = clickActionType,
                ComponentSlotType = TowerCompSlotType.None,
                IconAreaContext = new TowerIconAreaContext
                {
                    Rarity = tower.Rarity,
                    MuzzleColor = ResolveComponentColor(tower.MuzzleComponentInstanceId, muzzleMap),
                    BearingColor = ResolveComponentColor(tower.BearingComponentInstanceId, bearingMap),
                    BaseColor = ResolveComponentColor(tower.BaseComponentInstanceId, baseMap)
                }
            };
        }

        private static IconAreaContext BuildIconAreaContext(TowerCompItemData item)
        {
            if (item == null)
            {
                return new IconAreaContext
                {
                    ComponentSlotType = TowerCompSlotType.None,
                    Rarity = RarityType.None,
                    Color = Color.white,
                    Icon = null
                };
            }

            return new IconAreaContext
            {
                ComponentSlotType = item.SlotType,
                Rarity = item.Rarity,
                Color = IconColorGenerator.GenerateForComponent(item),
                Icon = null
            };
        }

        private static Color ResolveComponentColor<TComp>(long instanceId,
            IReadOnlyDictionary<long, TComp> componentMap)
            where TComp : TowerCompItemData
        {
            if (instanceId > 0 &&
                componentMap != null &&
                componentMap.TryGetValue(instanceId, out TComp component) &&
                component != null)
            {
                return IconColorGenerator.GenerateForComponent(component);
            }

            return Color.white;
        }
    }
}