using Platform;
using UnityEngine.Scripting;

#nullable disable
[Preserve]
public class BlockWorkstationRebirth : BlockParticle
{
    [PublicizedFrom(EAccessModifier.Protected)]
    public float TakeDelay;
    public WorkstationData WorkstationData;
    [PublicizedFrom(EAccessModifier.Private)]
    public string[] toolTransformNames;
    [PublicizedFrom(EAccessModifier.Protected)]
    public float CraftingParticleLightIntensity;
    [PublicizedFrom(EAccessModifier.Protected)]
    public new BlockActivationCommand[] cmds = new BlockActivationCommand[2]
    {
    new BlockActivationCommand("open", "campfire", true),
    new BlockActivationCommand("take", "hand", false)
    };

    public BlockWorkstationRebirth() => this.HasTileEntity = true;

    public override void Init()
    {
        //Log.Out("BlockWorkstation-Init START");
        base.Init();
        this.TakeDelay = 2f;
        this.Properties.ParseFloat("TakeDelay", ref this.TakeDelay);
        string optionalValue = "1,2,3";
        this.Properties.ParseString("Workstation.ToolNames", ref optionalValue);
        this.toolTransformNames = optionalValue.Split(',', StringSplitOptions.None);
        this.WorkstationData = new WorkstationData(this.GetBlockName(), this.Properties);
        CraftingManager.AddWorkstationData(this.WorkstationData);
    }

    public override void OnBlockAdded(WorldBase world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
    {
        //Log.Out("BlockWorkstation-OnBlockAdded START");
        base.OnBlockAdded(world, _chunk, _blockPos, _blockValue);
        if (_blockValue.ischild)
        {
            //Log.Out("BlockWorkstation-OnBlockAdded IS CHILD");
            return;
        }
        TileEntityWorkstationRebirth _te = new TileEntityWorkstationRebirth(_chunk);
        _te.localChunkPos = World.toBlock(_blockPos);
        _chunk.AddTileEntity((TileEntity)_te);
    }

    public override void OnBlockRemoved(
    WorldBase world,
    Chunk _chunk,
    Vector3i _blockPos,
    BlockValue _blockValue)
    {
        base.OnBlockRemoved(world, _chunk, _blockPos, _blockValue);

        TileEntity tileEntity = world.GetTileEntity(_blockPos);

        if (tileEntity is TileEntityWorkstationRebirth)
        {
            _chunk.RemoveTileEntityAt<TileEntityWorkstationRebirth>((World)world, World.toBlock(_blockPos));
        }
        else if (tileEntity is TileEntityWorkstation)
        {
            _chunk.RemoveTileEntityAt<TileEntityWorkstation>((World)world, World.toBlock(_blockPos));
        }
    }

    public override void PlaceBlock(WorldBase _world, BlockPlacement.Result _result, EntityAlive _ea)
    {
        //Log.Out("BlockWorkstation-PlaceBlock START");
        base.PlaceBlock(_world, _result, _ea);
        TileEntityWorkstationRebirth tileEntity = (TileEntityWorkstationRebirth)_world.GetTileEntity(_result.blockPos);
        if (tileEntity == null)
        {
            //Log.Out("BlockWorkstation-PlaceBlock CANNOT FIND TILE ENTITY");
            return;
        }
        tileEntity.IsPlayerPlaced = true;
        tileEntity.SetOwner(PlatformManager.InternalLocalUserIdentifier);
    }

    public override bool OnBlockActivated(
    WorldBase _world,
    int _cIdx,
    Vector3i _blockPos,
    BlockValue _blockValue,
    EntityPlayerLocal _player)
    {
        //Log.Out("BlockWorkstation-OnBlockActivated A START");

        TileEntity tileEntity = _player.world.GetTileEntity(_blockPos);

        if (!(tileEntity is TileEntityWorkstationRebirth ||
            tileEntity is TileEntityWorkstation))
        {
            return false;
        }

        _player.AimingGun = false;
        Vector3i worldPos = tileEntity.ToWorldPos();
        _world.GetGameManager().TELockServer(_cIdx, worldPos, tileEntity.entityId, _player.entityId);
        return true;
    }

    public override void OnBlockValueChanged(
    WorldBase _world,
    Chunk _chunk,
    int _clrIdx,
    Vector3i _blockPos,
    BlockValue _oldBlockValue,
    BlockValue _newBlockValue)
    {
        base.OnBlockValueChanged(_world, _chunk, _clrIdx, _blockPos, _oldBlockValue, _newBlockValue);
        this.checkParticles(_world, _clrIdx, _blockPos, _newBlockValue);
    }

    public override byte GetLightValue(BlockValue _blockValue) => 0;

    [PublicizedFrom(EAccessModifier.Protected)]
    public override void checkParticles(
      WorldBase _world,
      int _clrIdx,
      Vector3i _blockPos,
      BlockValue _blockValue)
    {
        if (_blockValue.ischild)
            return;
        bool flag = GameManager.Instance.HasBlockParticleEffect(_blockPos);
        if (_blockValue.meta != (byte)0 && !flag)
        {
            this.addParticles(_world, _clrIdx, _blockPos.x, _blockPos.y, _blockPos.z, _blockValue);
            if ((double)this.CraftingParticleLightIntensity <= 0.0)
                return;
            this.UpdateVisible(_world, _blockPos);
        }
        else
        {
            if (!(_blockValue.meta == (byte)0 & flag))
                return;
            this.removeParticles(_world, _blockPos.x, _blockPos.y, _blockPos.z, _blockValue);
        }
    }

    public static bool IsLit(BlockValue _blockValue) => _blockValue.meta > (byte)0;

    public override string GetActivationText(
      WorldBase _world,
      BlockValue _blockValue,
      int _clrIdx,
      Vector3i _blockPos,
      EntityAlive _entityFocusing)
    {
        return Localization.Get("useWorkstation");
    }

    public override bool OnBlockActivated(
      string _commandName,
      WorldBase _world,
      int _cIdx,
      Vector3i _blockPos,
      BlockValue _blockValue,
      EntityPlayerLocal _player)
    {
        //Log.Out("BlockWorkstation-OnBlockActivated B START");
        switch (_commandName)
        {
            case "open":
                return this.OnBlockActivated(_world, _cIdx, _blockPos, _blockValue, _player);
            case "take":
                this.TakeItemWithTimer(_cIdx, _blockPos, _blockValue, (EntityAlive)_player);
                return true;
            default:
                return false;
        }
    }

    public override bool HasBlockActivationCommands(
    WorldBase _world,
    BlockValue _blockValue,
    int _clrIdx,
    Vector3i _blockPos,
    EntityAlive _entityFocusing)
    {
        return true;
    }

    public override BlockActivationCommand[] GetBlockActivationCommands(
    WorldBase _world,
    BlockValue _blockValue,
    int _clrIdx,
    Vector3i _blockPos,
    EntityAlive _entityFocusing)
    {
        bool flag1 = _world.IsMyLandProtectedBlock(_blockPos, _world.GetGameManager().GetPersistentLocalPlayer());

        TileEntity tileEntity = _world.GetTileEntity(_blockPos);

        bool flag2 = false;
        bool flag3 = false;

        if (tileEntity is TileEntityWorkstationRebirth)
        {
            TileEntityWorkstationRebirth tileEntityWS = (TileEntityWorkstationRebirth)tileEntity;
            if (tileEntity != null)
            {
                flag2 = tileEntityWS.IsPlayerPlaced;
            }

            PersistentPlayerData playerData = _world.GetGameManager().GetPersistentPlayerList().GetPlayerData(tileEntityWS.GetOwner());

            if (playerData != null)
            {
                flag3 = true;
            }
        }
        else if (tileEntity is TileEntityWorkstation)
        {
            TileEntityWorkstation tileEntityWS = (TileEntityWorkstation)tileEntity;
            if (tileEntity != null)
            {
                flag2 = tileEntityWS.IsPlayerPlaced;
            }
        }

        //Log.Out("BlockWorkstationRebirth-GetBlockActivationCommands flag1: " + flag1);
        //Log.Out("BlockWorkstationRebirth-GetBlockActivationCommands flag2: " + flag2);
        //Log.Out("BlockWorkstationRebirth-GetBlockActivationCommands flag3: " + flag3);

        this.cmds[1].enabled = flag3 || (flag1 & flag2 && (double)this.TakeDelay > 0.0);
        return this.cmds;
    }

    [PublicizedFrom(EAccessModifier.Private)]
    public void TakeItemWithTimer(
    int _cIdx,
    Vector3i _blockPos,
    BlockValue _blockValue,
    EntityAlive _player)
    {
        if (_blockValue.damage > 0)
            GameManager.ShowTooltip(_player as EntityPlayerLocal, Localization.Get("ttRepairBeforePickup"), string.Empty, "ui_denied");
        else
        {
            TileEntity tileEntity = _player.world.GetTileEntity(_blockPos);

            bool take = false;

            if (tileEntity is TileEntityWorkstationRebirth)
            {
                TileEntityWorkstationRebirth tileEntityWS = (TileEntityWorkstationRebirth)tileEntity;
                if (!(GameManager.Instance.World.GetTileEntity(_blockPos) as TileEntityWorkstationRebirth).IsEmpty)
                {
                    GameManager.ShowTooltip(_player as EntityPlayerLocal, Localization.Get("ttWorkstationNotEmpty"), string.Empty, "ui_denied");
                }
                else
                {
                    take = true;
                }
            }
            else if (tileEntity is TileEntityWorkstation)
            {
                TileEntityWorkstation tileEntityWS = (TileEntityWorkstation)tileEntity;
                if (!(GameManager.Instance.World.GetTileEntity(_blockPos) as TileEntityWorkstation).IsEmpty)
                {
                    GameManager.ShowTooltip(_player as EntityPlayerLocal, Localization.Get("ttWorkstationNotEmpty"), string.Empty, "ui_denied");
                }
                else
                {
                    take = true;
                }
            }

            if (take)
            {
                LocalPlayerUI playerUi = (_player as EntityPlayerLocal).PlayerUI;
                playerUi.windowManager.Open("timer", true);
                XUiC_Timer childByType = playerUi.xui.GetChildByType<XUiC_Timer>();
                TimerEventData _eventData = new TimerEventData();
                _eventData.Data = (object)new object[4]
                {
                    (object) _cIdx,
                    (object) _blockValue,
                    (object) _blockPos,
                    (object) _player
                };
                _eventData.Event += new TimerEventHandler(this.EventData_Event);
                childByType.SetTimer(this.TakeDelay, _eventData);
            }
        }
    }

    [PublicizedFrom(EAccessModifier.Private)]
    public void EventData_Event(TimerEventData timerData)
    {
        World world = GameManager.Instance.World;
        object[] data = (object[])timerData.Data;
        int _clrIdx = (int)data[0];
        BlockValue blockValue = (BlockValue)data[1];
        Vector3i vector3i = (Vector3i)data[2];
        BlockValue block = world.GetBlock(vector3i);
        EntityPlayerLocal entityPlayerLocal = data[3] as EntityPlayerLocal;
        if (block.damage > 0)
            GameManager.ShowTooltip(entityPlayerLocal, Localization.Get("ttRepairBeforePickup"), string.Empty, "ui_denied");
        else if (block.type != blockValue.type)
            GameManager.ShowTooltip(entityPlayerLocal, Localization.Get("ttBlockMissingPickup"), string.Empty, "ui_denied");
        else
        {
            TileEntity tileEntity = entityPlayerLocal.world.GetTileEntity(vector3i);

            bool proceeed = false;

            if (tileEntity is TileEntityWorkstationRebirth)
            {
                TileEntityWorkstationRebirth tileEntityWS = (TileEntityWorkstationRebirth)tileEntity;

                if (tileEntityWS.IsUserAccessing())
                {
                    GameManager.ShowTooltip(entityPlayerLocal, Localization.Get("ttCantPickupInUse"), string.Empty, "ui_denied");
                }
                else
                {
                    proceeed = true;
                }
            }
            else if (tileEntity is TileEntityWorkstation)
            {
                TileEntityWorkstation tileEntityWS = (TileEntityWorkstation)tileEntity;

                if (tileEntityWS.IsUserAccessing())
                {
                    GameManager.ShowTooltip(entityPlayerLocal, Localization.Get("ttCantPickupInUse"), string.Empty, "ui_denied");
                }
                else
                {
                    proceeed = true;
                }
            }

            if (proceeed)
            {
                LocalPlayerUI uiForPlayer = LocalPlayerUI.GetUIForPlayer(entityPlayerLocal);
                ItemStack itemStack = new ItemStack(block.ToItemValue(), 1);
                if (!uiForPlayer.xui.PlayerInventory.AddItem(itemStack))
                    uiForPlayer.xui.PlayerInventory.DropItem(itemStack);
                world.SetBlockRPC(_clrIdx, vector3i, BlockValue.Air);
            }
        }
    }

    public override void OnBlockEntityTransformBeforeActivated(
    WorldBase _world,
    Vector3i _blockPos,
    BlockValue _blockValue,
    BlockEntityData _ebcd)
    {
        base.OnBlockEntityTransformBeforeActivated(_world, _blockPos, _blockValue, _ebcd);
        this.UpdateVisible(_world, _blockPos);
    }

    public void UpdateVisible(WorldBase _world, Vector3i _blockPos)
    {
        TileEntity tileEntity = _world.GetTileEntity(_blockPos);

        if (tileEntity is TileEntityWorkstationRebirth ||
            tileEntity is TileEntityWorkstation)
        {
            this.UpdateVisible(tileEntity);
        }
    }

    public void UpdateVisible(TileEntity tileEntity)
    {
        if (tileEntity is TileEntityWorkstationRebirth)
        {
            TileEntityWorkstationRebirth _te = (TileEntityWorkstationRebirth)tileEntity;

            BlockEntityData blockEntity = _te.GetChunk().GetBlockEntity(_te.ToWorldPos());
            if (blockEntity == null)
                return;
            Transform transform1 = blockEntity.transform;
            if (!(bool)(UnityEngine.Object)transform1)
                return;
            ItemStack[] tools = _te.Tools;
            int num = Utils.FastMin(tools.Length, this.toolTransformNames.Length);
            for (int index = 0; index < num; ++index)
            {
                Transform transform2 = transform1.Find(this.toolTransformNames[index]);
                if ((bool)(UnityEngine.Object)transform2)
                    transform2.gameObject.SetActive(!tools[index].IsEmpty());
            }
            Transform transform3 = transform1.Find("craft");
            if (!(bool)(UnityEngine.Object)transform3)
                return;
            bool isCrafting = _te.IsCrafting;
            transform3.gameObject.SetActive(isCrafting);
            if ((double)this.CraftingParticleLightIntensity <= 0.0)
                return;
            Transform blockParticleEffect = GameManager.Instance.GetBlockParticleEffect(_te.ToWorldPos());
            if ((bool)(UnityEngine.Object)blockParticleEffect)
            {
                Light componentInChildren = blockParticleEffect.GetComponentInChildren<Light>();
                if (!(bool)(UnityEngine.Object)componentInChildren)
                    return;
                componentInChildren.intensity = isCrafting ? this.CraftingParticleLightIntensity : 1f;
            }
            else
            {
                if (!isCrafting)
                    return;
                _te.SetVisibleChanged();
            }
        }
        else if (tileEntity is TileEntityWorkstation)
        {
            TileEntityWorkstation _te = (TileEntityWorkstation)tileEntity;

            BlockEntityData blockEntity = _te.GetChunk().GetBlockEntity(_te.ToWorldPos());
            if (blockEntity == null)
                return;
            Transform transform1 = blockEntity.transform;
            if (!(bool)(UnityEngine.Object)transform1)
                return;
            ItemStack[] tools = _te.Tools;
            int num = Utils.FastMin(tools.Length, this.toolTransformNames.Length);
            for (int index = 0; index < num; ++index)
            {
                Transform transform2 = transform1.Find(this.toolTransformNames[index]);
                if ((bool)(UnityEngine.Object)transform2)
                    transform2.gameObject.SetActive(!tools[index].IsEmpty());
            }
            Transform transform3 = transform1.Find("craft");
            if (!(bool)(UnityEngine.Object)transform3)
                return;
            bool isCrafting = _te.IsCrafting;
            transform3.gameObject.SetActive(isCrafting);
            if ((double)this.CraftingParticleLightIntensity <= 0.0)
                return;
            Transform blockParticleEffect = GameManager.Instance.GetBlockParticleEffect(_te.ToWorldPos());
            if ((bool)(UnityEngine.Object)blockParticleEffect)
            {
                Light componentInChildren = blockParticleEffect.GetComponentInChildren<Light>();
                if (!(bool)(UnityEngine.Object)componentInChildren)
                    return;
                componentInChildren.intensity = isCrafting ? this.CraftingParticleLightIntensity : 1f;
            }
            else
            {
                if (!isCrafting)
                    return;
                _te.SetVisibleChanged();
            }
        }
    }
}