using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;

using System;
using System.Collections;
using System.Linq.Expressions;
using System.ComponentModel;
using System.Collections.Generic;

using Object = UnityEngine.Object;
using Component = UnityEngine.Component;

public enum Folder
{
    Skill,
    Object,
    Shader,
    Garden,
    SpriteUI,
    PrefabUI,
    Character,
}

public enum ObjType
{
    Null,
    Flower,
    HudText,
    FlowerItem,
}

public class ManaReso : MonoBehaviour
{
    #region 变量

    public static Dictionary<string, Transform> TraDic;
    public static Dictionary<ObjType, Object> ObjDic;
    public static Dictionary<ObjType, List<GameObject>> ObjectPool;

    #endregion

    private void Awake()
    {
        TraDic = new Dictionary<string, Transform>();
        ObjDic = new Dictionary<ObjType, Object>();
        ObjectPool = new Dictionary<ObjType, List<GameObject>>();

        Get("ObjPool", Folder.Object, true, transform,  true);
        Get("MainCamera", Folder.Object, false, null,  true);
    }

    #region TraDic

    public static T Get<T>(string goName)
    {
        Transform tra;

        if (TraDic.TryGetValue(goName, out tra))
        {
            T t = tra.GetComponent<T>();

            if (t == null)
            {
                throw new Exception();
            }

            return t;
        }
        else
        {
            throw new Exception(goName);
        }
    }

    public static Transform Get(string goName)
    {
        Transform tra;

        if (TraDic.TryGetValue(goName, out tra))
        {
            return tra;
        }
        else
        {
            throw new Exception(goName);
        }
    }

    #endregion

    #region ObjPool

    public static void Save<T>(T t) where T : Component
    {
        GameObject go = t.gameObject;

        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out goList))
        {
            if (goList.Contains(go))
            {
                throw new Exception();
            }

            go.SetActive(false);

            goList.Add(go);

            go.transform.SetParent(Get("ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }

    public static void SaveUI<T>(T t) where T : Component
    {
        GameObject go = t.gameObject;

        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out goList))
        {
            if (goList.Contains(go))
            {
                throw new Exception();
            }

            go.SetActive(false);

            goList.Add(go);

            go.transform.SetParent(Get("J_ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }

    public static void Save(GameObject go)
    {
        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out goList))
        {
            if (goList.Contains(go))
            {
                throw new Exception();
            }

            go.SetActive(false);

            goList.Add(go);

            go.transform.SetParent(Get("ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }

    public static void SaveUI(GameObject go)
    {
        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out goList))
        {
            if (goList.Contains(go))
            {
                throw new Exception();
            }

            go.SetActive(false);

            goList.Add(go);

            go.transform.SetParent(Get("J_ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }


    public static T Get<T>(ObjType objType)
    {
        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objType, out goList))
        {
            if (goList.Count > 0)
            {
                GameObject go = goList[0];

                go.SetActive(true);
                goList.RemoveAt(0);

                T t = go.GetComponent<T>();

                if (t != null)
                {
                    return t;
                }
            }
        }

        return default(T);
    }

    public static Transform Get(Transform par, Vector3 pos, ObjType objType)
    {
        List<GameObject> goList;

        if (ObjectPool.TryGetValue(objType, out goList))
        {
            if (goList.Count > 0)
            {
                GameObject go = goList[0];

                go.SetActive(true);
                go.SetParent(par);
                go.transform.position = pos;

                goList.RemoveAt(0);

                return go.transform;
            }
        }

        return null;
    }


    public static Transform Get(string prefabName, Folder folder, bool compile, Transform par, Vector3 pos, ObjType objType = ObjType.Null)
    {
        if (objType != ObjType.Null)
        {
            Transform tra = Get(par, pos, objType);

            if (tra != null)
            {
                return tra;
            }
        }

        GameObject go = Load<GameObject>(prefabName, folder, objType);

        go = Instantiate(go, pos, Quaternion.identity, par);
        go.name = go.name.Replace("(Clone)", "");

        if (compile)
        {
            Auxiliary.CompileDic(go.transform, TraDic);
        }

        return go.transform;
    }

    public static Transform Get(string prefabName, Folder folder, bool compile, Transform par, bool worldSpace, ObjType objType = ObjType.Null)
    {
        GameObject go = Load<GameObject>(prefabName, folder, objType);

        go = Instantiate(go, par, worldSpace);
        go.name = go.name.Replace("(Clone)", "");

        if (compile)
        {
            Auxiliary.CompileDic(go.transform, TraDic);
        }

        return go.transform;
    }


    public static void GetHudText(string str, Transform posTra, bool scene, int size, Color color)
    {
        HudText hudText = Get<HudText>(ObjType.HudText);

        Vector3 pos;

        if (scene)
        {
            pos = Camera.main.WorldToScreenPoint(posTra.position);
        }
        else
        {
            pos = posTra.position;
        }

        if (hudText == null)
        {
            hudText = Get("HudText", Folder.PrefabUI, false, Get("HudParent"), pos, ObjType.HudText).AddComponent<HudText>();
            hudText.ObjType = ObjType.HudText;
        }
        else
        {
            hudText.transform.position = pos;
            hudText.transform.SetParent(Get("HudParent"));
        }

        hudText.Show(str, color, size);
    }

    public static Flower GetFlower(int id, bool collider, Transform posTra)
    {
        Flower flower = Get<Flower>(ObjType.Flower);

        if (flower == null)
        {
            flower = Get("Flower", Folder.Object, false, posTra, false, ObjType.Flower).AddComponent<Flower>();

            flower.ObjType = ObjType.Flower;
            flower.LocalPos = flower.transform.localPosition;
        }
        else
        {
            flower.transform.parent = posTra;
            flower.transform.localPosition = flower.LocalPos;
        }

        flower.Id = id;
        flower.PosTra = posTra;
        flower.SetCollider(collider);

        return flower;
    }

    #endregion

    #region ShortCut

    public static void SetText(string goName, string text)
    {
        Text tempText = Get<Text>(goName);

        tempText.text = text;
    }

    public static void SetSprite(string goName, Sprite sprite)
    {
        Image image = Get<Image>(goName);

        image.sprite = sprite;
    }

    public static void SetActive(string goName, bool active)
    {
        Get(goName).SetActive(active);
    }

    public static void SetButtonEvent(string goName, params UnityAction[] onClicks)
    {
        Button button = Get<Button>(goName);

        button.onClick = new Button.ButtonClickedEvent();

        for (int i = 0; i < onClicks.Length; i++)
        {
            button.onClick.AddListener(onClicks[i]);
        }
    }

    public static void AddButtonEvent(string goName, params UnityAction[] onClicks)
    {
        Button button = Get<Button>(goName);

        for (int i = 0; i < onClicks.Length; i++)
        {
            button.onClick.AddListener(onClicks[i]);
        }
    }

    #endregion

    public static T Load<T>(string name, Folder folder, ObjType objType = ObjType.Null) where T : Object
    {
        Object obj;
        
        if (ObjDic.TryGetValue(objType, out obj))
        {
            return (T) obj;
        }
        else
        {
            T t;

            if (folder == Folder.Skill)
            {
                t = Resources.Load<T>(@"Sprite\SpriteUI\Skill\" + name);
            }
            else if (folder == Folder.Object)
            {
                t = Resources.Load<T>(@"Prefab\Object\" + name);
            }
            else if (folder == Folder.Garden)
            {
                t = Resources.Load<T>(@"Sprite\Garden\" + name);
            }
            else if (folder == Folder.SpriteUI)
            {
                t = Resources.Load<T>(@"Sprite\SpriteUI\" + name);
            }
            else if (folder == Folder.Shader)
            {
                t = Resources.Load<T>(@"Shader\" + name);
            }
            else if (folder == Folder.PrefabUI)
            {
                t = Resources.Load<T>(@"Prefab\PrefabUI\" + name);
            }
            else if (folder == Folder.Character)
            {
                t = Resources.Load<T>(@"Sprite\Character\" + name);
            }
            else
            {
                throw new Exception();
            }

            if (t == null)
            {
                throw new Exception(name);
            }

            if (objType != ObjType.Null)
            {
                ObjDic.Add(objType, t);

                ObjectPool.Add(objType, new List<GameObject>());
            }

            return t;
        }
    }

    public static Transform GetSkillItem(SkillRoot skillRoot)
    {
        Transform tra;
        Dictionary<string, Transform> dic = new Dictionary<string, Transform>();

        if (skillRoot.Tab == SkillTab.Elf)
        {
            tra = Get("SkillItem", Folder.PrefabUI, false, Get("Fd_Grid"), false);
        }
        else if (skillRoot.Tab == SkillTab.Store)
        {
            tra = Get("SkillItem", Folder.PrefabUI, false, Get("Fc_Grid"), false);
        }
        else if (skillRoot.Tab == SkillTab.Magic)
        {
            tra = Get("SkillItem", Folder.PrefabUI, false, Get("Fb_Grid"), false);
        }
        else if (skillRoot.Tab == SkillTab.Garden)
        {
            tra = Get("SkillItem", Folder.PrefabUI, false, Get("Fa_Grid"), false);
        }
        else
        {
            throw new Exception();
        }

        Auxiliary.CompileDic(tra, dic);

        skillRoot.ItemTit = dic["Tit"].GetComponent<Text>();
        skillRoot.ItemBtn = dic["Btn"].GetComponent<Button>();
        skillRoot.ItemLab = dic["Lab"].GetComponent<Text>();
        skillRoot.ItemIcon = dic["Icon"].GetComponent<Image>();
        skillRoot.ItemBtnLab = dic["BtnLab"].GetComponent<Text>();

        if (!string.IsNullOrEmpty(skillRoot.Icon))
        {
            skillRoot.ItemIcon.sprite = Load<Sprite>(skillRoot.Icon, Folder.Skill);
        }

        return tra;
    }

    public static Transform GetFlowerCardItem()
    {
        Transform tra = Get<Transform>(ObjType.FlowerItem);

        if (tra == null)
        {
            ObjRoot objRoot = Get("FlowerCardItem", Folder.PrefabUI, false, Get("H_Grid"), false, ObjType.FlowerItem).AddComponent<ObjRoot>();

            objRoot.ObjType = ObjType.FlowerItem;

            return objRoot.transform;
        }
        else
        {
            tra.SetParent(Get("H_Grid"));

            return tra;
        }
    }
}