using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;

public enum EffectPlayTypes
{
    //None 이펙트의 경우는 이펙트 관리 대상에서 제외.
    None = 0,
    Oneshot,
    Loop,
}

public static class TransformEx
{

    public static void DoRecursively(this Transform root, System.Action<Transform> action, bool containMe = true)
    {
        if (containMe)
            action(root);
        foreach (Transform child in root)
            child.DoRecursively(action);
    }

}

public struct PlayEffectInfo
{
    public int dbId { get; set; }
    public string path { get; set; }
    public Transform rootTr { get; set; }
    public bool bAttached { get; set; }
    public Vector3 posOffset { get; set; }
    public Vector3 rot { get; set; }
    public Vector3 scale { get; set; }
    public EffectPlayTypes playEffectType { get; set; }
    public bool bUIEffect { get; set; }

    public PlayEffectInfo(string path, EffectPlayTypes type, Transform rootTr, Vector3 posOffset, Vector3 rot, Vector3 scale, int dbId = 0, bool bAttached = false, bool bUIEffect = false)
    {
        this.path = path;
        this.playEffectType = type;
        this.rootTr = rootTr;
        this.rot = rot;
        this.scale = scale;
        this.dbId = dbId;
        this.bAttached = bAttached;
        this.posOffset = posOffset;
        this.bUIEffect = bUIEffect;
    }
}

public class FxClear : MonoBehaviour
{
    [SerializeField]
    public float ClearTime = 2f;

    private EffectPlayTypes m_EffectPlayType = EffectPlayTypes.None;

    public float time { get { return m_curTime; } }

    private Transform m_rootTr = null;
    private float m_curTime = 0.0f;
    private bool m_bAttached = false;

    private Vector3 m_offset = Vector3.zero;
    private Vector3 m_rot = Vector3.zero;
    private Vector3 m_scale = Vector3.zero;

#if UNITY_EDITOR
    private double m_prevTime = 0.0f;
    private float m_removeWaitTime = 0.0f;
    private bool m_destroyRequested = false;
#endif

    private void Awake()
    {
        // 0 이면 무한 루프로 삭제하지 않게 사용하기로 그래픽과 합의함 - 해당 룰 그대로 가져옴(FxClear에서)
        if (ClearTime <= float.Epsilon)
            m_EffectPlayType = EffectPlayTypes.Loop;
    }

    private void Start()
    {
    }

    private void OnDestroy()
    {
        Release();
    }

    public void Initialize(PlayEffectInfo info)
    {
        m_EffectPlayType = info.playEffectType;
        //m_bExistTr = info.rootTr != null;
        m_rootTr = info.rootTr;
        m_curTime = 0.0f;
        m_offset = info.posOffset;
        m_rot = info.rot;
        m_scale = info.scale;
        m_bAttached = info.bAttached;

        SyncTr();
        gameObject.SetActive(true);
    }

    public void Release()
    {
        m_rootTr = null;
        m_curTime = 0.0f;
        m_bAttached = false;
        m_offset = Vector3.zero;
        m_rot = Vector3.zero;
        m_scale = Vector3.zero;
    }

    private void SyncTr()
    {
#if UNITY_EDITOR
		if (transform == null || transform.gameObject == null)
			return;
        //if (m_runInEditor)
        //{
        //    if (m_rootTr == null)
        //    { 
        //        transform.position = m_offset;
        //    }
        //    else
        //    {

        //        transform.localRotation = m_rootTr.rotation;

        //        if (m_bAttached)
        //        {
        //            transform.position = m_rootTr.position + (m_rootTr.rotation * m_offset);
        //        }
        //        else
        //        {
        //            transform.position = m_rootTr.position - (m_rootTr.rotation * m_offset);
        //        }
        //    }
        //}
        //else
        //{
            if (m_rootTr == null)
            {
                transform.position = m_offset;
            }
            else
            {
                if (m_bAttached)
                {
                    transform.localRotation = m_rootTr.rotation;// * Quaternion.LookRotation(Vector3.back);
                }
                else
                {
                    transform.localRotation = m_rootTr.rotation * Quaternion.LookRotation(Vector3.back);
                }

                transform.position = m_rootTr.position + (m_rootTr.rotation * m_offset);
            }
        //}
#else
        if (m_rootTr == null)
        {
            transform.position = m_offset;
        }
        else
        {
            if (m_bAttached)
            {
                transform.localRotation = m_rootTr.rotation;// * Quaternion.LookRotation(Vector3.back);
            }
            else
            {
                transform.localRotation = m_rootTr.rotation * Quaternion.LookRotation(Vector3.back);
            }

            transform.position = m_rootTr.position + (m_rootTr.rotation * m_offset);
        }
#endif

#if UNITY_EDITOR

        if (m_bAttached && m_rootTr != null)
        {
            transform.SetParent(m_rootTr);
        }

#else
        
        if (m_bAttached && m_rootTr != null)
        {
            transform.SetParent(m_rootTr);
        }

#endif
        if (m_rot != Vector3.zero)
        {
            transform.rotation = Quaternion.Euler(m_rot.x, m_rot.y, m_rot.z);
        }

        if (m_scale != Vector3.zero)
        {
            transform.localScale = m_scale;
        }
    }

    public void Restore()
    {
        DestroyImmediate(this.gameObject);
    }

    public void UpdateFunc(float dt)
    {
        m_curTime += dt;
        SyncTr();
        if (m_EffectPlayType != EffectPlayTypes.Loop && m_curTime >= ClearTime)
        {
            Restore();
            return;
        }
    }

    private void Update()
    {
        UpdateFunc(Time.unscaledDeltaTime);
    }
}