using Unity.Mathematics;

namespace DanieleMarotta.RiversongCodeShowcase
{
    public class HouseBuildingPanelSectionPresenter : IBuildingPanelSectionPresenter
    {
        private readonly IProductCatalog _productCatalog;

        public HouseBuildingPanelSectionPresenter(IProductCatalog productCatalog)
        {
            _productCatalog = productCatalog;
        }

        public bool IsSectionRelevant(Building building)
        {
            return building.Definition.IsHouse;
        }

        public void InitializeSection(BuildingPanelModel model, Building building)
        {
            var tiers = building.Definition.HouseTiers;
            var tierIndex = building.TierIndex;
            var maxTier = math.min(tierIndex, tiers.Count - 1);
            ref var needsState = ref building.GetNeedsStateRW();

            model.HouseModel.Needs.Clear();

            var rowIndex = 0;
            for (var i = 0; i <= maxTier; i++)
            {
                var tier = tiers[i];

                foreach (var need in tier.Needs)
                {
                    var needModel = new HousePanelNeedModel();

                    switch (need.Type)
                    {
                        case PopulationNeedType.Product:
                            needModel.Initialize(rowIndex++, need.Product.ProductName, need.Product.Icon, 0, need.YieldOnFetch);
                            break;
                    }

                    model.HouseModel.Needs.Add(needModel);
                }
            }

            model.HouseModel.AllNeedsMet = needsState.AllNeedsMet;
            model.HouseModel.UpgradeState = needsState.UpgradeState;

            model.HouseModel.UpgradeMaterials.Clear();
            if (tierIndex < tiers.Count)
                foreach (var productAmount in tiers[tierIndex].UpgradeMaterials)
                    model.HouseModel.UpgradeMaterials.Add(new HousePanelUpgradeMaterialModel(productAmount));

            model.HouseModel.NotifyChanged();
        }

        public void UpdateSection(BuildingPanelModel model, Building building)
        {
            ref var needsState = ref building.GetNeedsStateRW();
            ref var storage = ref building.GetStorageRW();

            for (var i = 0; i < needsState.Needs.Length; i++)
            {
                var need = needsState.Needs[i];
                if (need.TierIndex > building.TierIndex) break;

                var needModel = model.HouseModel.Needs[i];

                switch (need.Type)
                {
                    case PopulationNeedType.Product:
                        needModel.UpdateValue(need.Current);
                        break;
                }
            }

            model.HouseModel.AllNeedsMet = needsState.AllNeedsMet;
            model.HouseModel.UpgradeState = needsState.UpgradeState;

            foreach (var upgradeMaterialModel in model.HouseModel.UpgradeMaterials)
            {
                var productHandle = _productCatalog.GetHandle(upgradeMaterialModel.Product);
                upgradeMaterialModel.Remaining = math.max(upgradeMaterialModel.Needed - storage.AvailableNow(productHandle), 0);

                upgradeMaterialModel.Done &= needsState.UpgradeState != TierUpgradeState.NotReady;
                upgradeMaterialModel.Done |= upgradeMaterialModel.Remaining <= 0;
            }
        }
    }
}