// Decompiled with JetBrains decompiler
// Type: Terraria.GameContent.Tile_Entities.TEHatRack
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.IO;
using Terraria.Audio;
using Terraria.DataStructures;
using Terraria.GameInput;
using Terraria.UI;

namespace Terraria.GameContent.Tile_Entities
{
  public class TEHatRack : TileEntity
  {
    private static byte _myEntityID;
    private const int MyTileID = 475;
    private const int entityTileWidth = 3;
    private const int entityTileHeight = 4;
    private Player _dollPlayer;
    private Item[] _items;
    private Item[] _dyes;
    private static int hatTargetSlot;

    public TEHatRack()
    {
      this._items = new Item[2];
      for (int index = 0; index < this._items.Length; ++index)
        this._items[index] = new Item();
      this._dyes = new Item[2];
      for (int index = 0; index < this._dyes.Length; ++index)
        this._dyes[index] = new Item();
      this._dollPlayer = new Player();
      this._dollPlayer.hair = 15;
      this._dollPlayer.skinColor = Color.White;
      this._dollPlayer.skinVariant = 10;
    }

    public override void RegisterTileEntityID(int assignedID) => TEHatRack._myEntityID = (byte) assignedID;

    public override TileEntity GenerateInstance() => (TileEntity) new TEHatRack();

    public override void NetPlaceEntityAttempt(int x, int y) => NetMessage.SendData(86, number: TEHatRack.Place(x, y), number2: ((float) x), number3: ((float) y));

    public static int Place(int x, int y)
    {
      TEHatRack teHatRack = new TEHatRack();
      teHatRack.Position = new Point16(x, y);
      teHatRack.ID = TileEntity.AssignNewID();
      teHatRack.type = TEHatRack._myEntityID;
      TileEntity.ByID[teHatRack.ID] = (TileEntity) teHatRack;
      TileEntity.ByPosition[teHatRack.Position] = (TileEntity) teHatRack;
      return teHatRack.ID;
    }

    public static int Hook_AfterPlacement(
      int x,
      int y,
      int type = 475,
      int style = 0,
      int direction = 1,
      int alternate = 0)
    {
      if (Main.netMode != 1)
        return TEHatRack.Place(x - 1, y - 3);
      NetMessage.SendTileSquare(Main.myPlayer, x, y - 1, 5);
      NetMessage.SendData(87, number: (x - 1), number2: ((float) (y - 3)), number3: ((float) TEHatRack._myEntityID));
      return -1;
    }

    public static void Kill(int x, int y)
    {
      TileEntity tileEntity;
      if (!TileEntity.ByPosition.TryGetValue(new Point16(x, y), out tileEntity) || (int) tileEntity.type != (int) TEHatRack._myEntityID)
        return;
      TileEntity.ByID.Remove(tileEntity.ID);
      TileEntity.ByPosition.Remove(new Point16(x, y));
    }

    public static int Find(int x, int y)
    {
      TileEntity tileEntity;
      return TileEntity.ByPosition.TryGetValue(new Point16(x, y), out tileEntity) && (int) tileEntity.type == (int) TEHatRack._myEntityID ? tileEntity.ID : -1;
    }

    public override void WriteExtraData(BinaryWriter writer, bool networkSend)
    {
      BitsByte bitsByte = (BitsByte) (byte) 0;
      bitsByte[0] = !this._items[0].IsAir;
      bitsByte[1] = !this._items[1].IsAir;
      bitsByte[2] = !this._dyes[0].IsAir;
      bitsByte[3] = !this._dyes[1].IsAir;
      writer.Write((byte) bitsByte);
      for (int index = 0; index < 2; ++index)
      {
        Item obj = this._items[index];
        if (!obj.IsAir)
        {
          writer.Write((short) obj.netID);
          writer.Write(obj.prefix);
          writer.Write((short) obj.stack);
        }
      }
      for (int index = 0; index < 2; ++index)
      {
        Item dye = this._dyes[index];
        if (!dye.IsAir)
        {
          writer.Write((short) dye.netID);
          writer.Write(dye.prefix);
          writer.Write((short) dye.stack);
        }
      }
    }

    public override void ReadExtraData(BinaryReader reader, bool networkSend)
    {
      BitsByte bitsByte = (BitsByte) reader.ReadByte();
      for (int key = 0; key < 2; ++key)
      {
        this._items[key] = new Item();
        Item obj = this._items[key];
        if (bitsByte[key])
        {
          obj.netDefaults((int) reader.ReadInt16());
          obj.Prefix((int) reader.ReadByte());
          obj.stack = (int) reader.ReadInt16();
        }
      }
      for (int index = 0; index < 2; ++index)
      {
        this._dyes[index] = new Item();
        Item dye = this._dyes[index];
        if (bitsByte[index + 2])
        {
          dye.netDefaults((int) reader.ReadInt16());
          dye.Prefix((int) reader.ReadByte());
          dye.stack = (int) reader.ReadInt16();
        }
      }
    }

    public override string ToString() => this.Position.X.ToString() + "x  " + (object) this.Position.Y + "y item: " + (object) this._items[0] + " " + (object) this._items[1];

    public static void Framing_CheckTile(int callX, int callY)
    {
      if (WorldGen.destroyObject)
        return;
      int num1 = callX;
      int num2 = callY;
      Tile tileSafely = Framing.GetTileSafely(callX, callY);
      int num3 = num1 - (int) tileSafely.frameX / 18 % 3;
      int y = num2 - (int) tileSafely.frameY / 18 % 4;
      bool flag = false;
      for (int index1 = num3; index1 < num3 + 3; ++index1)
      {
        for (int index2 = y; index2 < y + 4; ++index2)
        {
          Tile tile = Main.tile[index1, index2];
          if (!tile.active() || tile.type != (ushort) 475)
            flag = true;
        }
      }
      if (!WorldGen.SolidTileAllowBottomSlope(num3, y + 4) || !WorldGen.SolidTileAllowBottomSlope(num3 + 1, y + 4) || !WorldGen.SolidTileAllowBottomSlope(num3 + 2, y + 4))
        flag = true;
      if (!flag)
        return;
      TEHatRack.Kill(num3, y);
      Item.NewItem(num3 * 16, y * 16, 48, 64, 3977);
      WorldGen.destroyObject = true;
      for (int i = num3; i < num3 + 3; ++i)
      {
        for (int j = y; j < y + 4; ++j)
        {
          if (Main.tile[i, j].active() && Main.tile[i, j].type == (ushort) 475)
            WorldGen.KillTile(i, j);
        }
      }
      WorldGen.destroyObject = false;
    }

    public void Draw(int tileLeftX, int tileTopY)
    {
      Player dollPlayer = this._dollPlayer;
      dollPlayer.direction = -1;
      dollPlayer.Male = true;
      if ((int) Framing.GetTileSafely(tileLeftX, tileTopY).frameX % 216 == 54)
        dollPlayer.direction = 1;
      dollPlayer.isDisplayDollOrInanimate = true;
      dollPlayer.isHatRackDoll = true;
      dollPlayer.armor[0] = this._items[0];
      dollPlayer.dye[0] = this._dyes[0];
      dollPlayer.ResetEffects();
      dollPlayer.ResetVisibleAccessories();
      dollPlayer.invis = true;
      dollPlayer.UpdateDyes();
      dollPlayer.DisplayDollUpdate();
      dollPlayer.PlayerFrame();
      Vector2 vector2_1 = new Vector2((float) tileLeftX + 1.5f, (float) (tileTopY + 4)) * 16f;
      dollPlayer.direction *= -1;
      Vector2 vector2_2 = new Vector2((float) (-dollPlayer.width / 2), (float) (-dollPlayer.height - 6)) + new Vector2((float) (dollPlayer.direction * 14), -2f);
      dollPlayer.position = vector2_1 + vector2_2;
      Main.PlayerRenderer.DrawPlayer(Main.Camera, dollPlayer, dollPlayer.position, 0.0f, dollPlayer.fullRotationOrigin);
      dollPlayer.armor[0] = this._items[1];
      dollPlayer.dye[0] = this._dyes[1];
      dollPlayer.ResetEffects();
      dollPlayer.ResetVisibleAccessories();
      dollPlayer.invis = true;
      dollPlayer.UpdateDyes();
      dollPlayer.DisplayDollUpdate();
      dollPlayer.skipAnimatingValuesInPlayerFrame = true;
      dollPlayer.PlayerFrame();
      dollPlayer.skipAnimatingValuesInPlayerFrame = false;
      dollPlayer.direction *= -1;
      Vector2 vector2_3 = new Vector2((float) (-dollPlayer.width / 2), (float) (-dollPlayer.height - 6)) + new Vector2((float) (dollPlayer.direction * 12), 16f);
      dollPlayer.position = vector2_1 + vector2_3;
      Main.PlayerRenderer.DrawPlayer(Main.Camera, dollPlayer, dollPlayer.position, 0.0f, dollPlayer.fullRotationOrigin);
    }

    public override string GetItemGamepadInstructions(int slot = 0)
    {
      Item[] inv = this._items;
      int slot1 = slot;
      int context = 26;
      if (slot >= 2)
      {
        slot1 -= 2;
        inv = this._dyes;
        context = 27;
      }
      return ItemSlot.GetGamepadInstructions(inv, context, slot1);
    }

    public override bool TryGetItemGamepadOverrideInstructions(
      Item[] inv,
      int context,
      int slot,
      out string instruction)
    {
      instruction = "";
      Item newItem = inv[slot];
      if (newItem.IsAir || newItem.favorited)
        return false;
      switch (context)
      {
        case 0:
          if (TEHatRack.FitsHatRack(newItem))
          {
            instruction = Lang.misc[76].Value;
            return true;
          }
          break;
        case 26:
        case 27:
          if (Main.player[Main.myPlayer].ItemSpace(newItem).CanTakeItemToPersonalInventory)
          {
            instruction = Lang.misc[68].Value;
            return true;
          }
          break;
      }
      return false;
    }

    public override void OnPlayerUpdate(Player player)
    {
      if (player.InInteractionRange(player.tileEntityAnchor.X, player.tileEntityAnchor.Y) && player.chest == -1 && player.talkNPC == -1)
        return;
      if (player.chest == -1 && player.talkNPC == -1)
        SoundEngine.PlaySound(11);
      player.tileEntityAnchor.Clear();
      Recipe.FindRecipes();
    }

    public static void OnPlayerInteraction(Player player, int clickX, int clickY)
    {
      int index1 = clickX;
      int index2 = clickY;
      int x1 = index1 - (int) Main.tile[index1, index2].frameX % 54 / 18;
      int y1 = index2 - (int) Main.tile[x1, index2].frameY / 18;
      int id = TEHatRack.Find(x1, y1);
      if (id == -1)
        return;
      int y2 = y1 + 1;
      int x2 = x1 + 1;
      TileEntity.BasicOpenCloseInteraction(player, x2, y2, id);
    }

    public override void OnInventoryDraw(Player player, SpriteBatch spriteBatch)
    {
      if (Main.tile[player.tileEntityAnchor.X, player.tileEntityAnchor.Y].type != (ushort) 475)
      {
        player.tileEntityAnchor.Clear();
        Recipe.FindRecipes();
      }
      else
        this.DrawInner(player, spriteBatch);
    }

    private void DrawInner(Player player, SpriteBatch spriteBatch)
    {
      Main.inventoryScale = 0.72f;
      this.DrawSlotPairSet(player, spriteBatch, 2, 0, 3.5f, 0.5f, 26);
    }

    private void DrawSlotPairSet(
      Player player,
      SpriteBatch spriteBatch,
      int slotsToShowLine,
      int slotsArrayOffset,
      float offsetX,
      float offsetY,
      int inventoryContextTarget)
    {
      Item[] items = this._items;
      for (int index1 = 0; index1 < slotsToShowLine; ++index1)
      {
        for (int index2 = 0; index2 < 2; ++index2)
        {
          int num1 = (int) (73.0 + ((double) index1 + (double) offsetX) * 56.0 * (double) Main.inventoryScale);
          int num2 = (int) ((double) Main.instance.invBottom + ((double) index2 + (double) offsetY) * 56.0 * (double) Main.inventoryScale);
          Item[] inv;
          int context;
          if (index2 == 0)
          {
            inv = this._items;
            context = inventoryContextTarget;
          }
          else
          {
            inv = this._dyes;
            context = 27;
          }
          if (Utils.FloatIntersect((float) Main.mouseX, (float) Main.mouseY, 0.0f, 0.0f, (float) num1, (float) num2, (float) TextureAssets.InventoryBack.Width() * Main.inventoryScale, (float) TextureAssets.InventoryBack.Height() * Main.inventoryScale) && !PlayerInput.IgnoreMouseInterface)
          {
            player.mouseInterface = true;
            ItemSlot.Handle(inv, context, index1 + slotsArrayOffset);
          }
          ItemSlot.Draw(spriteBatch, inv, context, index1 + slotsArrayOffset, new Vector2((float) num1, (float) num2));
        }
      }
    }

    public override bool OverrideItemSlotHover(Item[] inv, int context = 0, int slot = 0)
    {
      Item obj = inv[slot];
      if (!obj.IsAir && !inv[slot].favorited && context == 0 && TEHatRack.FitsHatRack(obj))
      {
        Main.cursorOverride = 9;
        return true;
      }
      if (obj.IsAir || context != 26 && context != 27 || !Main.player[Main.myPlayer].ItemSpace(inv[slot]).CanTakeItemToPersonalInventory)
        return false;
      Main.cursorOverride = 8;
      return true;
    }

    public override bool OverrideItemSlotLeftClick(Item[] inv, int context = 0, int slot = 0)
    {
      if (!ItemSlot.ShiftInUse)
        return false;
      if (Main.cursorOverride == 9 && context == 0)
      {
        Item obj = inv[slot];
        if (Main.cursorOverride == 9 && !obj.IsAir && !obj.favorited && context == 0 && TEHatRack.FitsHatRack(obj))
          return this.TryFitting(inv, context, slot);
      }
      if ((Main.cursorOverride != 8 || context != 23) && context != 26 && context != 27)
        return false;
      inv[slot] = Main.player[Main.myPlayer].GetItem(Main.myPlayer, inv[slot], GetItemSettings.InventoryEntityToPlayerInventorySettings);
      if (Main.netMode == 1)
        NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) this.ID), number3: ((float) slot));
      return true;
    }

    public static bool FitsHatRack(Item item) => item.maxStack <= 1 && item.headSlot > 0;

    private bool TryFitting(Item[] inv, int context = 0, int slot = 0, bool justCheck = false)
    {
      if (!TEHatRack.FitsHatRack(inv[slot]))
        return false;
      if (justCheck)
        return true;
      int index1 = TEHatRack.hatTargetSlot;
      ++TEHatRack.hatTargetSlot;
      for (int index2 = 0; index2 < 2; ++index2)
      {
        if (this._items[index2].IsAir)
        {
          index1 = index2;
          TEHatRack.hatTargetSlot = index2 + 1;
          break;
        }
      }
      for (int index3 = 0; index3 < 2; ++index3)
      {
        if (inv[slot].type == this._items[index3].type)
          index1 = index3;
      }
      if (TEHatRack.hatTargetSlot >= 2)
        TEHatRack.hatTargetSlot = 0;
      SoundEngine.PlaySound(7);
      Utils.Swap<Item>(ref this._items[index1], ref inv[slot]);
      if (Main.netMode == 1)
        NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) this.ID), number3: ((float) index1));
      return true;
    }

    public void WriteItem(int itemIndex, BinaryWriter writer, bool dye)
    {
      Item dye1 = this._items[itemIndex];
      if (dye)
        dye1 = this._dyes[itemIndex];
      writer.Write((ushort) dye1.netID);
      writer.Write((ushort) dye1.stack);
      writer.Write(dye1.prefix);
    }

    public void ReadItem(int itemIndex, BinaryReader reader, bool dye)
    {
      int Type = (int) reader.ReadUInt16();
      int num = (int) reader.ReadUInt16();
      int pre = (int) reader.ReadByte();
      Item dye1 = this._items[itemIndex];
      if (dye)
        dye1 = this._dyes[itemIndex];
      dye1.SetDefaults(Type);
      dye1.stack = num;
      dye1.Prefix(pre);
    }

    public override bool IsTileValidForEntity(int x, int y) => Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 475 && Main.tile[x, y].frameY == (short) 0 && (int) Main.tile[x, y].frameX % 54 == 0;

    public static bool IsBreakable(int clickX, int clickY)
    {
      int index1 = clickX;
      int index2 = clickY;
      int x = index1 - (int) Main.tile[index1, index2].frameX % 54 / 18;
      int y = index2 - (int) Main.tile[x, index2].frameY / 18;
      int key = TEHatRack.Find(x, y);
      return key == -1 || !(TileEntity.ByID[key] as TEHatRack).ContainsItems();
    }

    public bool ContainsItems()
    {
      for (int index = 0; index < 2; ++index)
      {
        if (!this._items[index].IsAir || !this._dyes[index].IsAir)
          return true;
      }
      return false;
    }
  }
}