using CIGEnums;
using SUISS.Core;
using SUISS.Scheduling;
using SUISSEngine;
using System.Collections.Generic;
using UnityEngine;

public class CIGScenery : Scenery
{
    public int happiness;

    public bool multiple;

    public Sprite[] sprites;

    public Island island;

    [SelfReference]
    public SpriteRenderer spriteRenderer;

    private CIGGameStats _gameStats;

    private CIGIslandState _islandState;

    protected int _effectiveHappiness;

    protected const string EffectiveHappinessKey = "EffectiveHappiness";

    private SpriteRenderer _spriteRenderer2;

    private SpriteRenderer _spriteRenderer3;

    private SpriteRenderer _spriteRenderer4;

    private MagicalReference<CIGExpansions> expansions = new MagicalReference<CIGExpansions>();

    private OverlayButtons _overlayButtons;

    protected CIGIslandState IslandState
    {
        get
        {
            if (_islandState == null)
            {
                _islandState = CityIsland.GetParent(this).islandState;
            }
            return _islandState;
        }
    }

    public override List<BuildingProperty> ShownProperties
    {
        get
        {
            List<BuildingProperty> shownProperties = base.ShownProperties;
            if (!shownProperties.Contains(BuildingProperty.Happiness) && happiness > 0)
            {
                shownProperties.Add(BuildingProperty.Happiness);
            }
            return shownProperties;
        }
    }

    public override bool CanDemolish
    {
        get
        {
            if (!base.CanDemolish)
            {
                return false;
            }
            if (base.state == BuildingState.Normal)
            {
                CIGExpansions.ExpansionBlock blockForIndex = expansions.reference.GetBlockForIndex(tile.index);
                if (blockForIndex != null && !blockForIndex.Unlocked)
                {
                    return false;
                }
            }
            return true;
        }
    }

    protected override void Awake()
    {
        base.Awake();
        _gameStats = SingletonMonobehaviour<CIGGameStats>.Instance;
    }

    protected void OnEnable()
    {
        GameEvents.Subscribe<UnemiShouldCloseEvent>(OnUnemiShouldCloseEvent);
    }

    protected void OnDisable()
    {
        GameEvents.Unsubscribe<UnemiShouldCloseEvent>(OnUnemiShouldCloseEvent);
    }

    protected override void OnSerialize(Dictionary<string, object> values)
    {
        base.OnSerialize(values);
        values["EffectiveHappiness"] = _effectiveHappiness;
    }

    protected override void OnDeserialize(Dictionary<string, object> values)
    {
        base.OnDeserialize(values);
        if (values.ContainsKey("EffectiveHappiness"))
        {
            _effectiveHappiness = (int)values["EffectiveHappiness"];
        }
    }

    protected override void OnGridTileStatusChanged(GridTile.Status oldStatus)
    {
        base.OnGridTileStatusChanged(oldStatus);
        if (tile.status == GridTile.Status.Created)
        {
            SingletonMonobehaviour<Scheduler>.Instance.ExecuteNextFrame(base.gameObject, GridTileStatus);
            SingletonMonobehaviour<Scheduler>.Instance.ExecuteNextFrame(base.gameObject, UpdateSprite);
        }
        else if (oldStatus == GridTile.Status.Created && tile.status == GridTile.Status.Destroyed)
        {
            UpdateNeighborSprites();
            GridTileStatus();
        }
    }

    protected void GridTileStatus()
    {
        if (tile.status == GridTile.Status.Created && happiness > _effectiveHappiness)
        {
            IslandState.AddHappiness(happiness - _effectiveHappiness);
            _effectiveHappiness = happiness;
            serializing.Serialize();
        }
        else if (tile.status == GridTile.Status.Destroyed && _effectiveHappiness > 0)
        {
            IslandState.AddHappiness(-_effectiveHappiness);
            _gameStats.AddNumberOfRocksRemoved(1);
            _effectiveHappiness = 0;
            serializing.Serialize();
        }
    }

    private CIGScenery GetMultiScenery(GridIndex index)
    {
        IsometricGrid grid = tile.grid;
        if (grid.IsWithinBounds(index) && grid[index].Tile != null)
        {
            CIGScenery component = grid[index.u, index.v].Tile.GetComponent<CIGScenery>();
            if (component != null && component.multiple)
            {
                return component;
            }
        }
        return null;
    }

    private bool HasMultiScenery(GridIndex index)
    {
        return GetMultiScenery(index) != null;
    }

    private int GetSpriteNumber(bool index1, bool index2, bool index3, bool index4)
    {
        int num = 0;
        if (index4)
        {
            num += 8;
        }
        if (index3)
        {
            num += 2;
        }
        if (index2)
        {
            num += 4;
        }
        if (index1)
        {
            num++;
        }
        return num;
    }

    private SpriteRenderer createSpriteRendererAt(int u, int v)
    {
        float x = tile.element.Grid.elementSize.x;
        float y = tile.element.Grid.elementSize.y;
        GameObject gameObject = new GameObject();
        gameObject.transform.parent = base.transform;
        gameObject.transform.localScale = Vector3.one;
        gameObject.name = "MultiScenerySprite" + u + "." + v;
        gameObject.transform.localPosition = new Vector2((float)(u - v) * x * 0.5f, (float)(u + v) * y * -0.5f);
        SpriteRenderer spriteRenderer = gameObject.AddComponent<SpriteRenderer>();
        spriteRenderer.sortingOrder = this.spriteRenderer.sortingOrder;
        return spriteRenderer;
    }

    public void UpdateNeighborSprites()
    {
        if (multiple)
        {
            GridIndex index = tile.index;
            CIGScenery multiScenery = GetMultiScenery(new GridIndex(index.u - 1, index.v));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u, index.v - 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u - 1, index.v - 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u + 1, index.v));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u, index.v + 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u + 1, index.v + 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u - 1, index.v + 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
            multiScenery = GetMultiScenery(new GridIndex(index.u + 1, index.v - 1));
            if (multiScenery != null)
            {
                multiScenery.UpdateSprite();
            }
        }
    }

    public void UpdateSprite()
    {
        if (!multiple)
        {
            return;
        }
        GridIndex index = tile.index;
        bool flag = true;
        bool flag2 = HasMultiScenery(new GridIndex(index.u - 1, index.v));
        bool flag3 = HasMultiScenery(new GridIndex(index.u, index.v - 1));
        bool index2 = HasMultiScenery(new GridIndex(index.u - 1, index.v - 1));
        bool flag4 = HasMultiScenery(new GridIndex(index.u + 1, index.v));
        bool flag5 = HasMultiScenery(new GridIndex(index.u, index.v + 1));
        bool flag6 = HasMultiScenery(new GridIndex(index.u + 1, index.v + 1));
        bool index3 = HasMultiScenery(new GridIndex(index.u + 1, index.v - 1));
        bool flag7 = HasMultiScenery(new GridIndex(index.u - 1, index.v + 1));
        spriteRenderer.sprite = sprites[GetSpriteNumber(index2, flag3, flag2, flag)];
        if (!flag4 && !flag3)
        {
            if (_spriteRenderer2 == null)
            {
                _spriteRenderer2 = createSpriteRendererAt(1, 0);
            }
            _spriteRenderer2.enabled = true;
            _spriteRenderer2.sprite = sprites[GetSpriteNumber(flag3, index3, flag, flag4)];
        }
        else if (_spriteRenderer2 != null)
        {
            _spriteRenderer2.enabled = false;
        }
        if (!flag6)
        {
            if (_spriteRenderer3 == null)
            {
                _spriteRenderer3 = createSpriteRendererAt(1, 1);
            }
            _spriteRenderer3.enabled = true;
            _spriteRenderer3.sprite = sprites[GetSpriteNumber(flag, flag4, flag5, flag6)];
        }
        else if (_spriteRenderer3 != null)
        {
            _spriteRenderer3.enabled = false;
        }
        if (!flag5 && !flag7 && !flag2)
        {
            if (_spriteRenderer4 == null)
            {
                _spriteRenderer4 = createSpriteRendererAt(0, 1);
            }
            _spriteRenderer4.enabled = true;
            _spriteRenderer4.sprite = sprites[GetSpriteNumber(flag2, flag, flag7, flag5)];
        }
        else if (_spriteRenderer4 != null)
        {
            _spriteRenderer4.enabled = false;
        }
    }

    protected override void ClickHandler(GameObject target)
    {
        base.ClickHandler(target);
        if (base.state != BuildingState.Demolishing && base.state != BuildingState.WaitingForDemolishing)
        {
            ToggleButtons();
        }
    }

    private void ToggleButtons()
    {
        if (_overlayButtons == null)
        {
            GameEvents.Invoke(new UnemiShouldCloseEvent(this));
            SingletonMonobehaviour<CIGAudioManager>.Instance.PlayClip(Clip.ButtonClick);
            _overlayButtons = OverlayButtons.Get(this);
            _overlayButtons.ShowOpenAnimation();
            _overlayButtons.DisableAllButtons();
            if (ShownProperties.Count > 0)
            {
                _overlayButtons.InfoButton.EnableButton(InfoAction);
            }
            if (CanDemolish)
            {
                _overlayButtons.DemolishButton.EnableButton(DemolishAction);
            }
        }
        else
        {
            RemoveButtons();
        }
    }

    private void RemoveButtons()
    {
        if ((bool)_overlayButtons)
        {
            OverlayButtons overlayButtonsTemp = _overlayButtons;
            overlayButtonsTemp.ShowCloseAnimation(delegate
            {
                UnityEngine.Object.Destroy(overlayButtonsTemp.gameObject);
            });
            _overlayButtons = null;
        }
    }

    private void InfoAction()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<BuildingInfoPopupState>(delegate (State state)
        {
            ((BuildingInfoPopupState)state).SetBuildingAndContent(this, BuildingPopupContent.Info);
        });
    }

    private void DemolishAction()
    {
        RemoveButtons();
        CityIsland.Current.isometricIsland.destroyer.DestroyBuilding(this);
    }

    private void OnUnemiShouldCloseEvent(UnemiShouldCloseEvent e)
    {
        RemoveButtons();
    }
}