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

public class eventTriggerSystem : MonoBehaviour
{
    public List<eventInfo> eventList = new List<eventInfo> ();
    public List<eventInfo> enterEventList = new List<eventInfo> ();
    public List<eventInfo> exitEventList = new List<eventInfo> ();
    public bool useSameFunctionInList;
    public List<string> sameFunctionList = new List<string> ();
    public bool useSameObjectToCall;
    public bool callThisObject;
    public GameObject sameObjectToCall;
    public bool triggeredByButton;
    public bool useObjectToTrigger;
    public GameObject objectNeededToTrigger;

    public bool useTagToTrigger;
    public string tagNeededToTrigger;
    public bool useTagList;
    public List<string> tagList = new List<string> ();

    public bool loopEventAtTheEndEnabled;

    public bool justCallOnTrigger;
    public bool callFunctionEveryTimeTriggered;
    public bool eventTriggered;

    public bool dontUseDelay;
    public bool useSameDelay;
    public float generalDelay;

    public bool useRandomDelay;
    public Vector2 randomDelayRange;

    public triggerType triggerEventType;
    public bool useLayerMask;
    public LayerMask layerMask;
    public bool coroutineActive;
    public bool setParentToNull;
    public GameObject objectDetected;

    public bool triggerEventAtStart;

    public enum triggerType
    {
        enter,
        exit,
        both
    }

    public bool isEnter;
    public bool isExit;

    Coroutine eventCoroutine;

    GameObject currentObjectToCall;

    void Start ()
    {
        if (triggerEventAtStart) {
            activateEvent ();
        }
    }

    public void activateEventIfObjectActiveSelf ()
    {
        if (gameObject.activeInHierarchy) {
            activateEvent ();
        }
    }

    public void activateEvent ()
    {
        if (!eventTriggered || callFunctionEveryTimeTriggered) {
            eventTriggered = true;

            if (setParentToNull) {
                transform.SetParent (null);
            }

            if (dontUseDelay) {
                activateEventAtOnce ();
            } else {
                stopEventCoroutine ();

                if (gameObject.activeInHierarchy) {
                    eventCoroutine = StartCoroutine (activateEventInTime ());
                }
            }
        }
    }

    public void stopEventCoroutineIfActive ()
    {
        if (coroutineActive) {
            stopEventCoroutine ();

            coroutineActive = false;
        }
    }

    public void stopEventCoroutine ()
    {
        if (eventCoroutine != null) {
            StopCoroutine (eventCoroutine);
        }
    }

    public void stopAllEventsAndDisableTriggerSystem ()
    {
        stopEventCoroutine ();

        eventTriggered = true;

        callFunctionEveryTimeTriggered = false;
    }

    IEnumerator activateEventInTime ()
    {
        coroutineActive = true;

        List<eventInfo> currentEventList = eventList;

        if (triggerEventType == triggerType.both) {
            if (isEnter) {
                currentEventList = enterEventList;
            }

            if (isExit) {
                currentEventList = exitEventList;
            }
        } else if (triggerEventType == triggerType.exit) {
            if (isExit) {
                currentEventList = exitEventList;
            }
        }

        int currentEventListCount = currentEventList.Count;

        for (int i = 0; i < currentEventListCount; i++) {
            if (useSameDelay) {
                float currentDelay = generalDelay;

                if (useRandomDelay) {
                    currentDelay = Random.Range (randomDelayRange.x, randomDelayRange.y);
                }

                WaitForSeconds delay = new WaitForSeconds (currentDelay);

                yield return delay;
            } else {
                float currentDelay = currentEventList [i].secondsDelay;

                if (currentEventList [i].useRandomDelay) {
                    currentDelay = Random.Range (currentEventList [i].randomDelayRange.x, currentEventList [i].randomDelayRange.y);
                }

                WaitForSeconds delay = new WaitForSeconds (currentDelay);

                yield return delay;
            }

            callElementFromList (currentEventList [i]);
        }

        coroutineActive = false;

        if (loopEventAtTheEndEnabled) {
            activateEvent ();
        }
    }

    public void activateEventAtOnce ()
    {
        List<eventInfo> currentEventList = eventList;

        if (triggerEventType == triggerType.both) {
            if (isEnter) {
                currentEventList = enterEventList;
            }

            if (isExit) {
                currentEventList = exitEventList;
            }
        } else if (triggerEventType == triggerType.exit) {
            if (isExit) {
                currentEventList = exitEventList;
            }
        }

        int currentEventListCount = currentEventList.Count;

        for (int i = 0; i < currentEventListCount; i++) {
            callElementFromList (currentEventList [i]);
        }
    }

    public void callElementFromList (eventInfo currentEventInfo)
    {
        if (useSameFunctionInList) {
            int sameFunctionListCount = sameFunctionList.Count;

            for (int j = 0; j < sameFunctionListCount; j++) {
                currentObjectToCall = getObjectToCall (currentEventInfo.objectToCall);

                if (currentObjectToCall != null) {
                    if (currentEventInfo.sendGameObject) {
                        currentObjectToCall.SendMessage (sameFunctionList [j], currentEventInfo.objectToSend, SendMessageOptions.DontRequireReceiver);
                    } else {
                        currentObjectToCall.SendMessage (sameFunctionList [j], SendMessageOptions.DontRequireReceiver);
                    }
                } else {
                    print ("WARNING: no object to call has been configure on the event trigger system " + gameObject.name + ", check it is correctly assigned");
                }
            }
        } else {
            if (currentEventInfo.useEventFunction) {
                if (currentEventInfo.sendObjectDetected) {
                    if (objectDetected != null) {

                        if (currentEventInfo.sendObjectDetectedByEvent) {
                            currentEventInfo.eventToSendObjectDetected.Invoke (objectDetected);
                        } else {
                            currentObjectToCall = getObjectToCall (currentEventInfo.objectToCall);

                            //							print (objectDetected.name + " " + currentObjectToCall.name);
                            if (currentObjectToCall != null) {
                                currentObjectToCall.SendMessage (currentEventInfo.sendObjectDetectedFunction, objectDetected, SendMessageOptions.DontRequireReceiver);
                            } else {
                                print ("WARNING: no object to call has been configure on the event trigger system " + gameObject.name + ", check it is correctly assigned");
                            }
                        }
                    }
                }

                if (currentEventInfo.useRemoteEvent) {
                    checkRemoteEventsOnObjectDetected (currentEventInfo, objectDetected);
                }

                currentEventInfo.eventFunction.Invoke ();

            } else {
                if (currentEventInfo.sendObjectDetected) {
                    if (objectDetected != null) {

                        if (currentEventInfo.sendObjectDetectedByEvent) {
                            currentEventInfo.eventToSendObjectDetected.Invoke (objectDetected);
                        } else {
                            currentObjectToCall = getObjectToCall (currentEventInfo.objectToCall);

                            if (currentObjectToCall != null) {

                                currentObjectToCall.SendMessage (currentEventInfo.sendObjectDetectedFunction, objectDetected, SendMessageOptions.DontRequireReceiver);

                            } else {
                                print ("WARNING: no object to call has been configure on the event trigger system " + gameObject.name + ", check it is correctly assigned");
                            }
                        }
                    }
                }

                if (currentEventInfo.useRemoteEvent) {
                    checkRemoteEventsOnObjectDetected (currentEventInfo, objectDetected);
                }

                if (currentEventInfo.useBroadcastMessage) {
                    int broadcastMessageStringListCount = currentEventInfo.broadcastMessageStringList.Count;

                    for (int j = 0; j < broadcastMessageStringListCount; j++) {
                        //						print (currentEventInfo.broadcastMessageStringList [j]);

                        currentObjectToCall = getObjectToCall (currentEventInfo.objectToCall);

                        if (currentObjectToCall != null) {
                            currentObjectToCall.BroadcastMessage (currentEventInfo.broadcastMessageStringList [j], SendMessageOptions.DontRequireReceiver);
                        } else {
                            print ("WARNING: no object to call has been configure on the event trigger system " + gameObject.name + ", check it is correctly assigned");
                        }
                    }
                } else {
                    int functionNameListCount = currentEventInfo.functionNameList.Count;

                    for (int j = 0; j < functionNameListCount; j++) {
                        currentObjectToCall = getObjectToCall (currentEventInfo.objectToCall);

                        if (currentObjectToCall != null) {
                            if (currentEventInfo.sendGameObject) {
                                currentObjectToCall.SendMessage (currentEventInfo.functionNameList [j], currentEventInfo.objectToSend, SendMessageOptions.DontRequireReceiver);
                            } else {
                                currentObjectToCall.SendMessage (currentEventInfo.functionNameList [j], SendMessageOptions.DontRequireReceiver);
                            }
                        } else {
                            print ("WARNING: no object to call has been configure on the event trigger system " + gameObject.name + ", check it is correctly assigned");
                        }
                    }
                }
            }
        }
    }

    void checkRemoteEventsOnObjectDetected (eventInfo currentEventInfo, GameObject newObjectDetected)
    {
        if (newObjectDetected != null) {
            remoteEventSystem currentRemoteEventSystem = newObjectDetected.GetComponent<remoteEventSystem> ();

            if (currentRemoteEventSystem == null) {
                playerComponentsManager currentPlayerComponetsManager = newObjectDetected.GetComponent<playerComponentsManager> ();

                if (currentPlayerComponetsManager != null) {
                    currentRemoteEventSystem = currentPlayerComponetsManager.getRemoteEventSystem ();
                }
            }

            if (currentRemoteEventSystem != null) {
                int remoteEventNameListCount = currentEventInfo.remoteEventNameList.Count;

                for (int i = 0; i < remoteEventNameListCount; i++) {
                    currentRemoteEventSystem.callRemoteEvent (currentEventInfo.remoteEventNameList [i]);
                }
            }
        }
    }

    public GameObject getObjectToCall (GameObject defaultObjectToCall)
    {
        GameObject objectToCall = defaultObjectToCall;

        if (useSameObjectToCall) {
            if (callThisObject) {
                objectToCall = gameObject;
            } else {
                objectToCall = sameObjectToCall;
            }
        }

        return objectToCall;
    }

    public void checkTriggerEventEnterType (GameObject objectToCheck)
    {
        checkTriggerEventType (objectToCheck, triggerType.enter);
    }

    public void checkTriggerEventExitType (GameObject objectToCheck)
    {
        checkTriggerEventType (objectToCheck, triggerType.exit);
    }

    public void checkTriggerEventType (GameObject objectToCheck, triggerType trigger)
    {
        if ((!eventTriggered || callFunctionEveryTimeTriggered) && !triggeredByButton) {
            if (trigger == triggerEventType || triggerEventType == triggerType.both) {

                if (triggerEventType == triggerType.both) {
                    if (trigger == triggerType.enter) {
                        isEnter = true;
                        isExit = false;
                    } else {
                        isEnter = false;
                        isExit = true;
                    }
                } else if (triggerEventType == triggerType.exit) {
                    if (isExit) {
                        isEnter = false;
                        isExit = true;
                    }
                }

                if (useObjectToTrigger) {
                    if (objectToCheck == objectNeededToTrigger) {
                        objectDetected = objectToCheck;

                        activateEvent ();
                    }
                }

                if (checkTag (objectToCheck)) {
                    objectDetected = objectToCheck;

                    activateEvent ();
                }

                if (justCallOnTrigger) {
                    objectDetected = objectToCheck;

                    activateEvent ();
                }
            }
        }
    }

    public GameObject getLastObjectDetected ()
    {
        return objectDetected;
    }

    public bool checkTag (GameObject objectToCheck)
    {
        if (useTagToTrigger) {
            if (useTagList) {
                if (tagList.Contains (objectToCheck.tag)) {
                    return true;
                }
            } else {
                if (objectToCheck.CompareTag (tagNeededToTrigger)) {
                    return true;
                }
            }
        }

        return false;
    }

    public void checkTriggerEventTypeByFunction ()
    {
        if ((!eventTriggered || callFunctionEveryTimeTriggered) && !triggeredByButton) {
            activateEvent ();
        }
    }

    public void resetEventTriggered ()
    {
        eventTriggered = false;
    }

    public void setEventAsTriggered ()
    {
        eventTriggered = true;
    }

    public void setObjectOnTriggerEnterExternally (GameObject newObject)
    {
        Collider newCollider = newObject.GetComponent<Collider> ();

        if (newCollider != null) {
            OnTriggerEnter (newCollider);
        }
    }

    public void setLoopEventAtTheEndEnabledState (bool state)
    {
        loopEventAtTheEndEnabled = state;
    }

    void OnTriggerEnter (Collider col)
    {
        //if it uses layermask and the object touched have a different layer, ignore it
        if (useLayerMask) {
            if ((1 << col.gameObject.layer & layerMask.value) != 1 << col.gameObject.layer) {
                return;
            }
        }

        checkTriggerEventType (col.gameObject, triggerType.enter);
    }

    void OnTriggerExit (Collider col)
    {
        //if it uses layermask and the object touched have a different layer, ignore it
        if (useLayerMask) {
            if ((1 << col.gameObject.layer & layerMask.value) != 1 << col.gameObject.layer) {
                return;
            }
        }

        checkTriggerEventType (col.gameObject, triggerType.exit);
    }

    //EDITOR FUNCTIONS
    public void addNewEvent ()
    {
        eventInfo newEvent = new eventInfo ();

        eventList.Add (newEvent);

        updateComponent ();
    }

    public void InsertEventAtIndex (int index)
    {
        eventInfo newEvent = new eventInfo ();

        eventList.Insert (index + 1, newEvent);

        updateComponent ();
    }

    public void setSimpleFunctionByTag (string functionName, GameObject objectTocall, string tag)
    {
        addNewEvent ();

        eventInfo newEvent = eventList [eventList.Count - 1];

        newEvent.objectToCall = objectTocall;

        newEvent.functionNameList.Add (functionName);

        useTagToTrigger = true;

        tagNeededToTrigger = tag;
    }

    public void setUseLayerMaskState (bool state)
    {
        useLayerMask = state;

        updateComponent ();
    }
    public void setLayerMaskValue (LayerMask newLayer)
    {
        layerMask = newLayer;

        updateComponent ();
    }

    public void setUseTagToTriggerState (bool state)
    {
        useTagToTrigger = state;

        updateComponent ();
    }

    public void setUseTagListState (bool state)
    {
        useTagList = state;

        updateComponent ();
    }
    
    public void setTagList (List<string> newList)
    {
        tagList = newList;

        updateComponent ();
    }

    public void addElementToTagList (string newElement)
    {
        if (!tagList.Contains (newElement)) {
            tagList.Add (newElement);

            updateComponent ();
        }
    }

    public void removeElementToTagList (string newElement)
    {
        if (tagList.Contains (newElement)) {
            tagList.Remove (newElement);

            updateComponent ();
        }
    }

    void updateComponent ()
    {
        GKC_Utils.updateComponent (this);

        GKC_Utils.updateDirtyScene ("Update Event Trigger System " + gameObject.name, gameObject);
    }

    [System.Serializable]
    public class eventInfo
    {
        public string name;
        public GameObject objectToCall;
        public List<string> functionNameList = new List<string> ();

        public float secondsDelay;
        public bool useRandomDelay;
        public Vector2 randomDelayRange;

        public bool sendGameObject;
        public GameObject objectToSend;
        public bool sendObjectDetected;
        public string sendObjectDetectedFunction;

        public bool sendObjectDetectedByEvent;
        public eventParameters.eventToCallWithGameObject eventToSendObjectDetected;

        public bool useEventFunction;

        public UnityEvent eventFunction = new UnityEvent ();

        public bool useBroadcastMessage;
        public List<string> broadcastMessageStringList = new List<string> ();

        public bool useRemoteEvent;
        public List<string> remoteEventNameList = new List<string> ();
    }
}