using CIG.Translation;
using CIGEnums;
using SUISS.Core;
using SUISSEngine;
using System;
using System.Collections;
using UnityEngine;

public class BuildingInfoPopupState : PopupBaseState
{
    public readonly BuildingProperty[] AllRequiredBuildingProperties = new BuildingProperty[7]
    {
        BuildingProperty.People,
        BuildingProperty.Employees,
        BuildingProperty.Profit,
        BuildingProperty.ProfitXp,
        BuildingProperty.TimeUntilProfit,
        BuildingProperty.Happiness,
        BuildingProperty.ConstructionXp
    };

    private BuildingPopupContent _content;

    private BonusFieldContent _bonusField;

    private Building _building;

    private CIGBuilding _cigBuilding;

    private Coroutine _updateBuildingInfoCoroutine;

    protected Building Building
    {
        get
        {
            return _building;
        }
        private set
        {
            _building = value;
            _cigBuilding = (value as CIGBuilding);
        }
    }

    public void SetBuildingAndContent(Building building, BuildingPopupContent content)
    {
        Building = building;
        _content = content;
        BuildingInfoPopupView buildingInfoPopupView = View as BuildingInfoPopupView;
        switch (_content)
        {
            case BuildingPopupContent.Info:
                buildingInfoPopupView.HideUpgradeButton();
                buildingInfoPopupView.HideBuildingSize();
                if (_cigBuilding != null && !_cigBuilding.Activated)
                {
                    buildingInfoPopupView.SetSubtitle(Localization.Key("building_activate"));
                }
                else
                {
                    buildingInfoPopupView.HideSubtitle();
                }
                goto default;
            case BuildingPopupContent.Activate:
                buildingInfoPopupView.SetUpgradeCosts(_cigBuilding.UpgradeCost);
                buildingInfoPopupView.HideBuildingSize();
                buildingInfoPopupView.SetSubtitle(Localization.Key("building_activate"));
                goto default;
            case BuildingPopupContent.Upgrade:
                {
                    buildingInfoPopupView.SetUpgradeCosts(_cigBuilding.UpgradeCost);
                    buildingInfoPopupView.HideBuildingSize();
                    int num = _cigBuilding.CurrentLevel - (_cigBuilding.activatable ? 1 : 0);
                    buildingInfoPopupView.SetSubtitle(Localization.Format("{0} ({1} {2})", Localization.Key("building_upgrade"), Localization.Key("level"), Localization.Integer(num + 1)));
                    _bonusField = BonusFieldContent.DeltaWithNextLevel;
                    break;
                }
            case BuildingPopupContent.Preview:
                {
                    buildingInfoPopupView.SetUpgradeCosts(_cigBuilding.PurchasePrice);
                    buildingInfoPopupView.SetBuildingSize(new GridSize(Building.tile.gridSizeU, Building.tile.gridSizeV));
                    int requiredGridType2 = building.tile.requiredGridType;
                    if (requiredGridType2 != 10)
                    {
                        SurfaceType surfaceType2 = (SurfaceType)requiredGridType2;
                        string arg2 = surfaceType2.ToString().ToLower().Replace("driedswamp", "swamp");
                        string key2 = $"surfacetype_{arg2}";
                        buildingInfoPopupView.SetSubtitle(Localization.Concat(Localization.Format(Localization.Key("must_be_built_on"), Localization.Key(key2))));
                    }
                    else
                    {
                        buildingInfoPopupView.HideSubtitle();
                    }
                    goto default;
                }
            case BuildingPopupContent.ReadOnly:
                {
                    buildingInfoPopupView.HideUpgradeButton();
                    buildingInfoPopupView.SetBuildingSize(new GridSize(Building.tile.gridSizeU, Building.tile.gridSizeV));
                    int requiredGridType = building.tile.requiredGridType;
                    if (requiredGridType != 10)
                    {
                        SurfaceType surfaceType = (SurfaceType)requiredGridType;
                        string arg = surfaceType.ToString().ToLower().Replace("driedswamp", "swamp");
                        string key = $"surfacetype_{arg}";
                        buildingInfoPopupView.SetSubtitle(Localization.Concat(Localization.Format(Localization.Key("must_be_built_on"), Localization.Key(key))));
                    }
                    else
                    {
                        buildingInfoPopupView.HideSubtitle();
                    }
                    goto default;
                }
            default:
                _bonusField = BonusFieldContent.Empty;
                break;
        }
        buildingInfoPopupView.UpdateInfo(Building);
        if (_updateBuildingInfoCoroutine != null)
        {
            StopCoroutine(_updateBuildingInfoCoroutine);
            _updateBuildingInfoCoroutine = null;
        }
        _updateBuildingInfoCoroutine = StartCoroutine(UpdateBuildingInfoRoutine());
    }

    public void RequestPurchase()
    {
        if (_content == BuildingPopupContent.Preview)
        {
            PopupManager instance = SingletonMonobehaviour<PopupManager>.Instance;
            bool suppressQueue = instance.SuppressQueue;
            instance.SuppressQueue = true;
            instance.CloseRecursive();
            if (!SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
            {
                CityIsland.Current.StartBuilding(_building.gameObject);
            }
            if (!suppressQueue)
            {
                instance.SuppressQueue = false;
            }
        }
        else if (_cigBuilding != null)
        {
            if (SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
            {
                ClosePopup();
                return;
            }
            if (!_cigBuilding.CanUpgrade)
            {
                ILocalizedString title;
                ILocalizedString reason = _cigBuilding.ReasonWhyCantUpgrade(out title);
                if (reason != null && reason != Localization.EmptyLocalizedString)
                {
                    ClosePopup(delegate
                    {
                        SingletonMonobehaviour<PopupManager>.Instance.ShowInfoPopup(title, reason);
                    });
                    return;
                }
            }
            CIGBuilding building = _cigBuilding;
            Action callback = delegate
            {
                if (!building.StartUpgrade())
                {
                    ILocalizedString title2;
                    ILocalizedString localizedString = building.ReasonWhyCantUpgrade(out title2);
                    if (localizedString != null && localizedString != Localization.EmptyLocalizedString)
                    {
                        SingletonMonobehaviour<PopupManager>.Instance.ShowInfoPopup(title2, localizedString);
                    }
                }
            };
            ClosePopup(callback);
        }
        else
        {
            UnityEngine.Debug.LogWarning($"{Building.gameObject.name} is not a UpgradableBuilding");
        }
    }

    public override void Leave(State newState)
    {
        base.Leave(newState);
        if (_updateBuildingInfoCoroutine != null)
        {
            StopCoroutine(_updateBuildingInfoCoroutine);
            _updateBuildingInfoCoroutine = null;
        }
    }

    private IEnumerator UpdateBuildingInfoRoutine()
    {
        if (Building != null)
        {
            ((BuildingInfoPopupView)View).SetBuildingSprites(Building);
            while (Building != null)
            {
                if (!_isInState)
                {
                    yield break;
                }
                FillProperties();
                yield return new WaitForSeconds((!Building.InfoRequiresFrequentRefresh) ? 60f : 1f);
            }
        }
        _updateBuildingInfoCoroutine = null;
    }

    private void FillProperties()
    {
        foreach (BuildingProperty shownProperty in Building.ShownProperties)
        {
            ILocalizedString value = GetValue(shownProperty);
            ILocalizedString bonus;
            switch (_bonusField)
            {
                default:
                    bonus = Localization.EmptyLocalizedString;
                    break;
                case BonusFieldContent.DeltaWithNextLevel:
                    bonus = GetLevelUp(shownProperty);
                    break;
            }
            ((BuildingInfoPopupView)View).SetInfoLine(shownProperty, value, bonus);
        }
    }

    private ILocalizedString GetValue(BuildingProperty property)
    {
        switch (property)
        {
            case BuildingProperty.ConstructionXp:
                return (!(_cigBuilding == null)) ? Localization.Integer(_cigBuilding.constructionXP.GetValue("XP")) : Localization.EmptyLocalizedString;
            case BuildingProperty.Employees:
                {
                    CIGCommercialBuilding cIGCommercialBuilding = (CIGCommercialBuilding)Building;
                    if (_content == BuildingPopupContent.Activate || !_cigBuilding.Activated || _content == BuildingPopupContent.Preview || _content == BuildingPopupContent.ReadOnly)
                    {
                        return Localization.Integer(cIGCommercialBuilding.maxEmployeesBaseValue);
                    }
                    return Localization.Format(Localization.Key("progress"), Localization.Integer(cIGCommercialBuilding.Employees), Localization.Integer(cIGCommercialBuilding.MaxEmployees));
                }
            case BuildingProperty.Happiness:
                {
                    if (_content == BuildingPopupContent.Activate || (_cigBuilding != null && !_cigBuilding.Activated) || _content == BuildingPopupContent.Preview || _content == BuildingPopupContent.ReadOnly)
                    {
                        return Localization.Integer(_cigBuilding.baseHappinessValue);
                    }
                    int? num = null;
                    if (Building is CIGScenery)
                    {
                        num = ((CIGScenery)Building).happiness;
                    }
                    else if (_cigBuilding != null)
                    {
                        num = _cigBuilding.Happiness;
                    }
                    if (!num.HasValue)
                    {
                        return Localization.EmptyLocalizedString;
                    }
                    return Localization.Integer(num.Value);
                }
            case BuildingProperty.People:
                {
                    CIGResidentialBuilding cIGResidentialBuilding = (CIGResidentialBuilding)Building;
                    if (_content == BuildingPopupContent.Activate || !_cigBuilding.Activated || _content == BuildingPopupContent.Preview || _content == BuildingPopupContent.ReadOnly)
                    {
                        return Localization.Integer(cIGResidentialBuilding.maxPeopleBaseValue);
                    }
                    return Localization.Format(Localization.Key("progress"), Localization.Integer(cIGResidentialBuilding.People), Localization.Integer(cIGResidentialBuilding.MaxPeople));
                }
            case BuildingProperty.Profit:
                {
                    Currencies zero = Currencies.Zero;
                    zero = ((_content != BuildingPopupContent.Activate && _cigBuilding.Activated && _content != BuildingPopupContent.Preview && _content != BuildingPopupContent.ReadOnly) ? ((CIGCommercialBuilding)Building).Profit.WithoutXPCurrency() : ((CIGCommercialBuilding)Building).baseProfitCurrencies.WithoutXPCurrency());
                    return Localization.Integer((int)zero.GetValue("Cash"));
                }
            case BuildingProperty.ProfitXp:
                {
                    decimal num2 = 0m;
                    num2 = ((_content != BuildingPopupContent.Activate && _cigBuilding.Activated && _content != BuildingPopupContent.Preview && _content != BuildingPopupContent.ReadOnly) ? ((CIGCommercialBuilding)Building).Profit.GetValue("XP") : ((CIGCommercialBuilding)Building).baseProfitCurrencies.GetValue("XP"));
                    return Localization.Integer(num2);
                }
            case BuildingProperty.TimeUntilProfit:
                if (_content == BuildingPopupContent.Activate || !_cigBuilding.Activated || _content == BuildingPopupContent.Upgrade || _content == BuildingPopupContent.Preview || _content == BuildingPopupContent.ReadOnly)
                {
                    return Localization.TimeSpan(TimeSpan.FromSeconds(((CIGCommercialBuilding)Building).profitTime), hideSecondPartWhenZero: false);
                }
                return ((CIGCommercialBuilding)Building).TimeLeftString();
            case BuildingProperty.Text:
                return Building.InfoText();
            default:
                return Localization.Literal("ERROR");
        }
    }

    private ILocalizedString GetLevelUp(BuildingProperty property)
    {
        int num = 0;
        switch (property)
        {
            case BuildingProperty.Employees:
                {
                    CIGCommercialBuilding cIGCommercialBuilding = (CIGCommercialBuilding)Building;
                    num = cIGCommercialBuilding.UpgradeJobs(cIGCommercialBuilding.CurrentLevel + 1);
                    break;
                }
            case BuildingProperty.Happiness:
                if (Building is CIGCommunityBuilding)
                {
                    num = ((CIGCommunityBuilding)Building).UpgradeHappiness(_cigBuilding.CurrentLevel + 1);
                }
                break;
            case BuildingProperty.People:
                num = ((CIGResidentialBuilding)Building).UpgradePeople(_cigBuilding.CurrentLevel + 1);
                break;
            case BuildingProperty.Profit:
                {
                    Currencies currencies = ((CIGCommercialBuilding)Building).UpgradeProfit(_cigBuilding.CurrentLevel + 1).WithoutXPCurrency();
                    num = (int)currencies.GetValue("Cash");
                    break;
                }
            case BuildingProperty.ProfitXp:
                {
                    decimal value = ((CIGCommercialBuilding)Building).UpgradeProfit(_cigBuilding.CurrentLevel + 1).GetValue("XP");
                    num = Mathf.RoundToInt((float)value);
                    break;
                }
            case BuildingProperty.TimeUntilProfit:
            case BuildingProperty.ConstructionXp:
            case BuildingProperty.Text:
                num = 0;
                break;
            default:
                return Localization.Literal("ERROR");
        }
        if (num > 0)
        {
            return Localization.Format(Localization.Key("plus"), Localization.Integer(num));
        }
        return Localization.EmptyLocalizedString;
    }
}