Character

using UnityEngine;
using Assets.Scripts.Stats;
using UnityEngine.UI;
using System.Collections;
using System;

public class Character : MonoBehaviour
{
    #region Stat Parameters

    public int Health = 100;

    /// <summary>
    /// Character Attributes
    /// </summary>
    public Stat Strength;
    public Stat Agility;
    public Stat Intelligence;
    public Stat Vitality;

    /// <summary>
    /// Defensive Scores
    /// </summary>
    public Stat Defense;
    public Stat Evasion;

    /// <summary>
    /// Offensive Scores
    /// </summary>
    public Stat Damage;
    public Stat CriticalChance;

    #endregion

    [SerializeField] GameObject characterPanel;
    [SerializeField] Inventory inventory;
    [SerializeField] EquipmentManager equipmentPanel;
    [SerializeField] CraftingWindow craftingWindow;
    [SerializeField] StatPanel statPanel;
    [SerializeField] ItemTooltip itemTooltip;
    [SerializeField] Image draggableItem;

    [SerializeField] GameObject playerObject;

    public AbilitySystemHelper _ash;

    private BaseItemSlot dragItemSlot;

    private void OnValidate()
    {
        if (itemTooltip == null)
            itemTooltip = FindObjectOfType<ItemTooltip>();
    }

    private void Awake()
    {
        statPanel.SetStats(Strength, Agility, Intelligence, Vitality, Damage, CriticalChance, Defense, Evasion);
        Initialize();
        statPanel.UpdateStatValues();
        _ash = GetComponentInChildren<AbilitySystemHelper>();

        // Setup Events:
        // Right Click
        inventory.OnRightClickEvent += InventoryRightClick;
        equipmentPanel.OnRightClickEvent += EquipmentPanelRightClick;
        // Pointer Enter
        inventory.OnPointerEnterEvent += ShowTooltip;
        equipmentPanel.OnPointerEnterEvent += ShowTooltip;
        craftingWindow.OnPointerEnterEvent += ShowTooltip;
        // Pointer Exit
        inventory.OnPointerExitEvent += HideTooltip;
        equipmentPanel.OnPointerExitEvent += HideTooltip;
        craftingWindow.OnPointerExitEvent += HideTooltip;
        // Begin Drag
        inventory.OnBeginDragEvent += BeginDrag;
        equipmentPanel.OnBeginDragEvent += BeginDrag;
        // End Drag
        inventory.OnEndDragEvent += EndDrag;
        equipmentPanel.OnEndDragEvent += EndDrag;
        // Drag
        inventory.OnDragEvent += Drag;
        equipmentPanel.OnDragEvent += Drag;
        //Drop
        inventory.OnDropEvent += Drop;
        equipmentPanel.OnDropEvent += Drop;
    }

    private void Update()
    {
        CheckCharacterPanelStatus();
    }

    private void CheckCharacterPanelStatus()
    {
        CharacterController cntrl = playerObject.GetComponent<CharacterController>();
        if (characterPanel.activeSelf)
        {
            cntrl.enabled = false;
        }
        else if (!characterPanel.activeSelf)
        {
            cntrl.enabled = true;
        }
    }

    private void InventoryRightClick(BaseItemSlot itemSlot)
    {
        if (itemSlot.Item is EquippableItem)
        {
            var equipmentType = itemSlot.Item as EquippableItem;

            // Handle swapping of equipment here if the piece of equipment
            // is the same type as an already equipped item in said slot


            Equip((EquippableItem)itemSlot.Item);
        }
        else if (itemSlot.Item is UsableItem)
        {
            UsableItem usableItem = (UsableItem)itemSlot.Item;
            usableItem.Use(this);

            if (usableItem.IsConsumable)
            {
                inventory.RemoveItem(usableItem);
                usableItem.Destroy();
            }
        }
    }

    private void EquipmentPanelRightClick(BaseItemSlot itemSlot)
    {
        if (itemSlot.Item is EquippableItem)
        {
            Unequip((EquippableItem)itemSlot.Item);
        }
    }

    private void ShowTooltip(BaseItemSlot itemSlot)
    {
        if (itemSlot.Item != null)
        {
            itemTooltip.ShowTooltip(itemSlot.Item);
        }
    }

    private void HideTooltip(BaseItemSlot itemSlot)
    {
        itemTooltip.HideTooltip();
    }

    private void BeginDrag(BaseItemSlot itemSlot)
    {
        if (itemSlot.Item != null)
        {
            dragItemSlot = itemSlot;
            draggableItem.sprite = itemSlot.Item.Icon;
            draggableItem.transform.position = Input.mousePosition;
            draggableItem.gameObject.SetActive(true);
        }
    }

    private void Drag(BaseItemSlot itemSlot)
    {
        draggableItem.transform.position = Input.mousePosition;
    }

    private void EndDrag(BaseItemSlot itemSlot)
    {
        dragItemSlot = null;
        draggableItem.gameObject.SetActive(false);
    }

    private void Drop(BaseItemSlot dropItemSlot)
    {
        if (dragItemSlot == null) return;

        if (dropItemSlot is EquipmentSlot)
        {
            EquipByDragAndDrop(dropItemSlot);
        }
        else if (dropItemSlot is InventorySlot)
        {
            if (dragItemSlot is EquipmentSlot)
                UnEquipByDragAndDrop(dropItemSlot);
        }

        try
        {
            if (dropItemSlot.CanAddStack(dragItemSlot.Item))
            {
                AddStacks(dropItemSlot);
            }
            else if (!dropItemSlot.CanReceiveItem(dragItemSlot.Item) && !dragItemSlot.CanReceiveItem(dropItemSlot.Item))
            {
                SwapItems(dropItemSlot);
            }
        }
        catch (NullReferenceException ex)
        {
            Debug.Log($"Technical Debt issue: {ex.ToString()}");
            // This occurs because of the if "if (dropItemSlot.CanAddStack(dragItemSlot.Item))"
            // Need to make it so it doesn't need to check if dropItemSlot can add stacks
            // Not all instances of dropItemSlot apply to adding stacks
        }

    }

    private void EquipByDragAndDrop(BaseItemSlot dropItemSlot)
    {
        EquippableItem dragItem = dragItemSlot.Item as EquippableItem;
        EquipmentSlot dropSlot = dropItemSlot as EquipmentSlot;

        //Debug.Log($"item being dragged is: {dragItem}, item being dropped in a: {dropSlot.EquipmentType} slot");
        if (dragItem.EquipmentType == dropSlot.EquipmentType)
        {
            //Debug.Log($"Equipping {dragItem} to {dropSlot.EquipmentType} slot");
            Equip(dragItem);
        }
    }

    private void UnEquipByDragAndDrop(BaseItemSlot dropItemSlot)
    {
        EquippableItem dragItem = dragItemSlot.Item as EquippableItem;
        InventorySlot dropSlot = dropItemSlot as InventorySlot;
        var slotIndex = equipmentPanel.EquipmentSlotIndex((EquipmentSlot)dragItemSlot);
        var itemToDispose = equipmentPanel.equipmentHelper.equipmentSlotMeshObject[slotIndex];

        //Debug.Log($"item being dragged is: {dragItem}, item being dropped in a: {dropSlot} slot");
        //Debug.Log(equipmentPanel.EquipmentSlotIndex((EquipmentSlot)dragItemSlot));

        if (dropSlot.Item == null)
        {
            //Debug.Log($"Removing {dragItem} from {dragItemSlot}, adding {dragItem} back to {dropSlot} slot");
            Unequip(dragItem);
        }
    }

    private void SwapItems(BaseItemSlot dropItemSlot)
    {
        EquippableItem dragItem = dragItemSlot.Item as EquippableItem;
        EquippableItem dropItem = dropItemSlot.Item as EquippableItem;

        if (dropItemSlot is EquipmentSlot)
        {
            if (dragItem != null) dragItem.Equip(this);
            if (dropItem != null) dropItem.Unequip(this);
        }
        if (dragItemSlot is EquipmentSlot)
        {
            if (dragItem != null) dragItem.Unequip(this);
            if (dropItem != null) dropItem.Equip(this);
        }
        statPanel.UpdateStatValues();

        Item draggedItem = dragItemSlot.Item;
        int draggedItemAmount = dragItemSlot.Amount;

        dragItemSlot.Item = dropItemSlot.Item;
        dragItemSlot.Amount = dropItemSlot.Amount;

        dropItemSlot.Item = draggedItem;
        dropItemSlot.Amount = draggedItemAmount;
    }

    private void AddStacks(BaseItemSlot dropItemSlot)
    {
        int numAddableStacks = dropItemSlot.Item.MaximumStacks - dropItemSlot.Amount;
        int stacksToAdd = Mathf.Min(numAddableStacks, dragItemSlot.Amount);

        dropItemSlot.Amount += stacksToAdd;
        dragItemSlot.Amount -= stacksToAdd;
    }

    private void Initialize()
    {
        Strength.BaseValue = 5.0f;
        Agility.BaseValue = 5.0f;
        Intelligence.BaseValue = 5.0f;
        Vitality.BaseValue = 5.0f;

        Damage.BaseValue = 15.0f;
        CriticalChance.BaseValue = 10.0f;
        Defense.BaseValue = 35.0f;
        Evasion.BaseValue = 15.0f;
    }

    public void Equip(EquippableItem item)
    {
        if (inventory.RemoveItem(item))
        {
            EquippableItem previousItem;
            if (equipmentPanel.AddItem(item, out previousItem))
            {
                if (previousItem != null)
                {
                    inventory.AddItem(previousItem);
                    previousItem.Unequip(this);
                    statPanel.UpdateStatValues();
                    if (equipmentPanel.equipmentHelper.CheckEquippedItemName(previousItem.ItemName))
                    {
                        equipmentPanel.equipmentHelper.RemoveUnequippedItem(previousItem.name);
                    }
                }
                item.Equip(this);
                statPanel.UpdateStatValues();
                equipmentPanel.equipmentHelper.isDirty = true;
            }
            else
            {
                inventory.AddItem(item);
            }
        }
    }

    public void Unequip(EquippableItem item)
    {
        if (inventory.CanAddItem(item))
        {
            equipmentPanel.RemoveItem(item);
            item.Unequip(this);
            statPanel.UpdateStatValues();
            inventory.AddItem(item);
        }
    }

    public void UpdateStatValues()
    {
        statPanel.UpdateStatValues();
    }
}