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

[RequireComponent (typeof (BoxCollider2D))]
public class MovingPlattform : MonoBehaviour {

    public List<Vector2> m_Points;
    public List<string> m_Tags;
    [SerializeField] private float m_Speed = 0.3f; //plattform geschwindigkeit
    [SerializeField] private float m_Wait = 2f; //zeit in Sekunden wie lange die Plattform wartet
    [SerializeField] private int m_StartIndex = 0; //Index in der Liste an der die Plattform starten soll
    [SerializeField] private bool m_MoveingByTouching = false; //plattform bewegt sich nur bei Spieler Kontakt
    [SerializeField] private bool m_Loop = false; //Bool zur festlegung ob plattform sich loopen soll

    private bool isMoving = false; //Bool zu Checken ob Plattform sich bewegt kann auch genutzt werden um festzustellen ob die Coroutine Move(Vector2 a, Vector2 b) läuft
    private bool isFacingForward = true; //sagt aus in welche Richtung sich die Plattform bewegt
    private int isAt = 0; //Index an welcher stelle sich die Plattform in der List m_Points befindet

    private Vector2 origin = Vector2.zero;

    void Awake () {
        origin = transform.position;
        SetStart (m_StartIndex);
    }

    void Update () {
        if (m_Points.Count <= 1 || isMoving) return;

        if (!m_MoveingByTouching)
            Patrol ();
    }

    //Setze die Startposition der Plattform.
    public void SetStart (int index) {
        if (index >= 0 && index < m_Points.Count) {
            this.isAt = index;
            transform.position = origin + m_Points[isAt];
        }
    }

    //entscheidet ob die Plattformpatrolie läuft in einer Schleife oder die Plattform bewegt sich vor und zurück
    private void Patrol () {
        if (!m_Loop) {
            //Controls movement back an forth
            if (isFacingForward) {
                MoveForward ();
            } else {
                MoveBackward ();
            }
        } else {
            //Loops plattform motion forward. Can be Backwards
            MoveForward ();
        }
    }

    private void MoveForward () {
        if ((isAt + 1) < m_Points.Count) {
            //normale vor und zurück bewegung
            StartCoroutine (Move (origin + m_Points[isAt], origin + m_Points[isAt + 1]));
            ++isAt;
        } else if ((isAt + 1) > m_Points.Count && m_Loop) {
            //Loop sprung der Plattform
            StartCoroutine (Move (origin + m_Points[isAt], origin + m_Points[0]));
            isAt = 0;
        } else {
            //setzten in welche richtung die Plattform sich bewegt
            isFacingForward = false;
        }
    }

    //selbe wie bei MoveForward nur Backwards
    private void MoveBackward () {
        if ((isAt - 1) >= 0) {
            StartCoroutine (Move (origin + m_Points[isAt], origin + m_Points[isAt - 1]));
            isAt--;
        } else if ((isAt - 1) < 0 && m_Loop) {
            StartCoroutine (Move (origin + m_Points[isAt], origin + m_Points[m_Points.Count - 1]));
            isAt = m_Points.Count - 1;
        } else {
            isFacingForward = true;
        }
    }

    //Coroutine zur bewegung der Plattform
    private IEnumerator Move (Vector2 a, Vector2 b) {
        isMoving = true;
        for (float i = 0; i <= 1f; i += (m_Speed * Time.deltaTime)) {
            transform.position = Vector2.Lerp (a, b, i);
            yield return new WaitForEndOfFrame ();
        }
        yield return new WaitForSeconds (m_Wait);
        isMoving = false;
    }

    //CollisionEnter mit Spieler kann um Gegner erweitert werden
    void OnCollisionEnter2D (Collision2D col2D)
    {
	    bool found = false;
	    for (int i = 0; i < m_Tags.Count; i++)
	    {
		    if (col2D.gameObject.tag.Equals(m_Tags[i]) || col2D.gameObject.tag.Equals("Player"))
		    {
			    //Setzt parent object des Spielers zu dieser Plattform somit wird die transformation der Plattform auf den Spieler Übertragen
			    col2D.transform.SetParent (gameObject.transform);
			    found |= true;
		    }
	    }

	    if (m_MoveingByTouching && m_Points.Count > 1 && found)
		    Patrol ();
    }

    //CollisionExit mit Spieler kann um Gegner erweitert werden
    void OnCollisionExit2D (Collision2D col2D) {

	    for (int i = 0; i < m_Tags.Count; i++)
	    {
		    if (col2D.gameObject.tag.Equals(m_Tags[i]) || col2D.gameObject.tag.Equals("Player"))
		    {
			    //Sets Spieler Parent zu niemand
			    col2D.transform.SetParent (null);
		    }
	    }
    }

    void OnDrawGizmosSelected () {
        Vector2 pos = transform.position;
        if (m_Points != null) {
            for (int i = 0; i < m_Points.Count; i++) {
                Gizmos.color = Color.green;
                Gizmos.DrawSphere (pos + m_Points[i], 0.1f);

                Gizmos.color = Color.blue;
                if (i + 1 < m_Points.Count) {
                    Gizmos.DrawLine (pos + m_Points[i], pos + m_Points[i + 1]);
                } else if (i + 1 >= m_Points.Count && m_Loop) {
                    Gizmos.DrawLine (pos + m_Points[i], pos + m_Points[0]);
                }

            }
        }
    }
}