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

public class CurveController : MonoBehaviour
{

    public List<GameObject> points;
    public List<GameObject> holders;
    public GameObject pointPrefab;
    public MainRightPanel mainGUI;

    public Transform tractor;
    public Transform holder;

    public Text metricsText;

    public List<Transform> allPoints;

    public static CurveController Instance;

    public GameObject trakedObject;

    public bool tracking = false;

    public float StartingRotation = 0;

    public Material APlusMaterial;

    public Button aButton;
    public Button abButton;

    public Material lineMaterial;
    public Material sideLineMaterial;

    public GameObject uiCounter;
    public List<ParalelsCounter> counters;
    public ParalelsCounter centerCounter;
    public int countDelta = 0;
    private bool finishTracking = false;
    private float deltaLast = 0;

    public List<Vector3> testPoints;

    private bool needToTest = true;

    private Dictionary<int, List<Vector3>> curveSaver;

    void Start()
    {
        Instance = this;

        StartCoroutine(TrackPosition());

        if (SaveController.Instance.data.curves != null && SaveController.Instance.data.curves.Count > 0)
        {
            SetFromSave();
            aButton.interactable = false;
            abButton.interactable = false;
        }

        if(testPoints.Count > 0 && needToTest)
        {
            Invoke("SpawnTest",1);
        }

        curveSaver = new Dictionary<int, List<Vector3>>();
    }

    public void SpawnTest()
    {
        foreach (Vector3 vec in testPoints)
        {
            SetPosition(vec);
        }

        FinishTracking();
    }

    public void CheckAfterMove()
    {
        if (SaveController.Instance.data.curves == null || SaveController.Instance.data.curves.Count == 0)
        {
            aButton.interactable = true;
        }
    }

    IEnumerator TrackPosition()
    {
        while (true)
        {
            if (tracking && TractorController.Instance.trailer[0].transform.parent == null)
            {
                SetPosition(tractor);
                if (CheckIfPlayerLookToStart())
                {

                    holder.transform.GetChild(holder.transform.childCount - 1).SetParent(null);
                    holder.transform.GetChild(holder.transform.childCount - 1).SetParent(null);
                    FinishTracking();
                }
            }
            else
            {
                /*Transform gm = GetClosestPoint(allPoints);
                if (gm != null)
                {
                    trakedObject = gm.gameObject;
                }*/
            }
            yield return new WaitForSeconds(1.5f);
        }
    }

    private bool CheckIfPlayerLookToStart()
    {
        if (points.Count > 0)
        {
            Vector3 first = points[0].transform.eulerAngles;
            Vector3 second = TractorController.Instance.transform.eulerAngles;

            float res = first.y - second.y;
            if (res < -180)
                res += 180;
            if (res > 180)
            {
                res -= 180;
            }
            /*if ((res < -65 && res > -115) || (res > 65 && res < 115) || (res <=-170 && res >=-180))
                return true;*/
        }
        return false;
    }

    private void SetFromSave()
    {
        for (int i = 0; i < SaveController.Instance.data.curves.Count - 1; i++)
        {
            GameObject obj = GameObject.Instantiate(pointPrefab) as GameObject;
            obj.transform.position = new Vector3(SaveController.Instance.data.curves[i].position.x, SaveController.Instance.data.curves[i].position.y, SaveController.Instance.data.curves[i].position.z);
            //obj.transform.eulerAngles = new Vector3(p.rotation.x, p.rotation.y, p.rotation.z);
            SetPosition(obj.transform);
        }

        FinishTracking();
    }

    public void SetPosition(Transform position)
    {
        if (points.Count > 0)
        {
            if (position.position != points[points.Count - 1].transform.position)
            {
                GameObject obj = GameObject.Instantiate(pointPrefab, position.position, position.rotation) as GameObject;
                points.Add(obj);

                if (points.Count == 1)
                {
                    holder.transform.position = position.position;
                    holder.transform.rotation = position.rotation;
                }
                obj.transform.SetParent(holder);
            }
        }
        else
        {
            StartingRotation = position.eulerAngles.y;
            GameObject obj = GameObject.Instantiate(pointPrefab, position.position, position.rotation) as GameObject;
            points.Add(obj);

            if (points.Count == 1)
            {
                holder.transform.position = position.position;
                holder.transform.rotation = position.rotation;
            }
            obj.transform.SetParent(holder);

            GameObject objj = GameObject.Instantiate(pointPrefab, position.position, position.rotation) as GameObject;
            objj.transform.eulerAngles = new Vector3(0, objj.transform.eulerAngles.y - 180, 0);
            objj.transform.localScale = new Vector3(18.83506f, 0.01f, 18.83506f);
            objj.GetComponent<Renderer>().material = APlusMaterial;
        }


        //if (points.Count >= 2)
        //{
        //    IndicatorPanel.Instance.gameObject.SetActive(true);
        //    SetRenderer();
        //}
    }

    public void SetPosition(Vector3 position)
    {
        if (points.Count > 0)
        {
            if (position != points[points.Count - 1].transform.position)
            {
                GameObject obj = GameObject.Instantiate(pointPrefab) as GameObject;
                obj.transform.position = position;
                points.Add(obj);

                if (points.Count == 1)
                {
                    holder.transform.position = position;
                }
                obj.transform.SetParent(holder);
            }
        }
        else
        {
            GameObject obj = GameObject.Instantiate(pointPrefab) as GameObject;
            obj.transform.position = position;
            points.Add(obj);

            if (points.Count == 1)
            {
                holder.transform.position = position;
            }
            obj.transform.SetParent(holder);

            GameObject objj = GameObject.Instantiate(pointPrefab) as GameObject;
            objj.transform.position = position;
            objj.transform.eulerAngles = new Vector3(0, objj.transform.eulerAngles.y - 180, 0);
            objj.transform.localScale = new Vector3(18.83506f, 0.01f, 18.83506f);
            objj.GetComponent<Renderer>().material = APlusMaterial;
        }


        //if (points.Count >= 2)
        //{
        //    IndicatorPanel.Instance.gameObject.SetActive(true);
        //    SetRenderer();
        //}
    }

    public void ResetSave()
    {
        if(SaveController.Instance.data.curves != null)
            SaveController.Instance.data.curves.Clear();
        if (holder.transform.childCount > 0)
        {
             for (int i = 0; i < holder.transform.childCount; i++)
            {
                SavePoint(holder.transform.GetChild(i).gameObject);
            }
        }

        SaveController.Instance.InsertCurves();
    }

    private void SavePoint(GameObject obj)
    {
        CurvePoint point = new CurvePoint();
        Vector vector = new Vector();
        Rotation rot = new Rotation();
        vector.x = obj.transform.position.x;
        vector.y = obj.transform.position.y;
        vector.z = obj.transform.position.z;

        rot.x = obj.transform.eulerAngles.x;
        rot.y = obj.transform.eulerAngles.y;
        rot.z = obj.transform.eulerAngles.z;

        point.position = vector;
        point.rotation = rot;
        SaveController.Instance.data.curves.Add(point);
    }

    public void DestroyAll()
    {
        for (int i = holder.transform.childCount - 1; i >= 0; i--)
        {
            Destroy(holder.transform.GetChild(i).gameObject);
        }
        for (int i = 0; i < holders.Count; i++)
        {
            Destroy(holders[i]);
        }
        points.Clear();
        allPoints.Clear();
        holders.Clear();
    }

    public void ResetCurves( GameObject parent)
    {
        if (parent == holder.gameObject)
        {
            return;
        }

        if (parent.GetComponent<CurveCounter>().side == CurveSide.Left)
        {
            countDelta--;
        }
        else
        {
            countDelta++;
        }

        centerCounter.SetText("");
        Destroy(parent.transform.GetChild(0).GetComponent<BoxCollider>());
        Destroy(parent.transform.GetChild(parent.transform.childCount - 1).GetComponent<BoxCollider>());



        GameObject objj = new GameObject("startingPos");
        objj.transform.position = parent.transform.position;
        objj.transform.eulerAngles = parent.transform.eulerAngles;
        startingPos = objj;
        Destroy(holder.gameObject);
        holder = parent.transform;
        holders.Remove(parent);
        foreach (GameObject obj in holders)
        {
            Destroy(obj);
        }




        holders.Clear();
        allPoints.Clear();
        counters.Clear();
        holder.transform.position = objj.transform.position;

        for (int i = 0; i < holder.transform.childCount; i++)
        {
            allPoints.Add(holder.transform.GetChild(i));
        }

        FinishTracking();



        SetMaterials();
    }

    public Vector3 frontForward;
    public Vector3 rearForward;

    public Vector3 frontEuler;
    public Vector3 rearEuler;

    public void SetTrackedPoint(GameObject obj)
    {
        int i = -1;
        i = allPoints.IndexOf(obj.transform);
        if (i == -1)
        {
            return;
        }
        List<Transform> temp = new List<Transform>();
        temp.Add(allPoints[i]);
        if (i > 0)
        {
            temp.Add(allPoints[i - 1]);
        }
        if (i + 1 < allPoints.Count)
        {
            temp.Add(allPoints[i + 1]);
        }
        Transform gm = GetClosestPoint(allPoints);
        if (gm != null)
        {
            trakedObject = gm.gameObject;
        }
    }

    public bool firstTime = true;

    public GameObject startingPos = null;

    public void SetBezierCurve()
    {
       /* List<Vector3> ppp = GetDrawingPoints();
        List<GameObject> forDestroy = new List<GameObject>();
        //holder.DetachChildren();
        for (int i = 1; i < ppp.Count; i++)
        {
            if (i < points.Count)
            {
                points[i].transform.position = ppp[i-1];
                points[i].name = points[i].name + "New";
            }
            else
            {
                GameObject obj = new GameObject("point");
                obj.transform.position = ppp[i - 1];// points[i];
                SetPosition(obj.transform);
                //forDestroy.Add(obj);
            }
        }

        for (int i = forDestroy.Count - 1; i >= 0; i--)
        {
            points.Remove(forDestroy[i]);
            Destroy(forDestroy[i]);
        }*/

        StartCoroutine(StartPoints());
    }

    public IEnumerator StartPoints()
    {
        yield return new WaitForSeconds(0.5f);
        FinishTracking();
    }

    float lastDeltaa = 0;
    private GameObject originalLine;
    public void FinishTracking()
    {

        counters.Clear();
        tracking = false;
        if (firstTime)
        {
            Vector3 first = points[0].transform.eulerAngles;
            int j = 0;
            holder.transform.GetChild(holder.transform.childCount - 1).eulerAngles = holder.transform.GetChild(0).eulerAngles;
            // holder.transform.GetChild(j - 1).gameObject.SetActive(false);// = first;
            if (j - 1 < holder.childCount)
            {
               // holder.GetChild(j - 1).eulerAngles = first;
                //holder.GetChild(j - 2).eulerAngles = first;
            }

           /* List<Vector3> position = new List<Vector3>();

            foreach (GameObject o in points)
            {
                position.Add(o.transform.position);
            }

            position = MakeSmoothCurve(position, 32f);
            points.Clear();
            for (int i = 0; i < position.Count; i++)
            {
                GameObject ob = new GameObject();
                ob.transform.SetParent(holder);
                points.Add(ob);
                points[i].transform.position = position[i];
            }*/

            //MakeSmoothCurve(10f);
            /*for (int i = 0; i < holder.transform.childCount; i++)
            {
                holder.GetChild(i).eulerAngles = first;
            }*/
            SetLines(holder.gameObject);

            for (int i = 0; i < holder.transform.childCount; i++)
            {
                if (i + 1 < holder.transform.childCount && holder.transform.GetChild(i + 1).gameObject.activeSelf)
                {
                    GameObject obj1 = holder.transform.GetChild(i).gameObject;
                    GameObject obj2 = holder.transform.GetChild(i + 1).gameObject;

                        obj1.transform.LookAt(obj2.transform);

                    if (obj1.GetComponent<BoxCollider>() != null)
                        Destroy(obj1.GetComponent<BoxCollider>());

                    if (i < holder.transform.childCount - 3)
                    {

                        BoxCollider col = obj1.AddComponent<BoxCollider>();
                        obj1.GetComponent<BoxCollider>().isTrigger = true;
                        col.isTrigger = true;

                        col.size = new Vector3(4, 1, Vector3.Distance(obj1.transform.position, obj2.transform.position));
                        col.center = new Vector3(0, 0, Vector3.Distance(obj1.transform.position, obj2.transform.position) / 2);
                    }


                }

                allPoints.Add(holder.transform.GetChild(i));
                SavePoint(holder.transform.GetChild(i).gameObject);
            }
            firstTime = false;

            foreach (var g in allPoints)
            {
                g.transform.SetParent(null);
            }
            holder.eulerAngles = allPoints[0].eulerAngles;
            foreach (var g in allPoints)
            {
                g.transform.SetParent(holder);
            }

            GameObject counter = GameObject.Instantiate(uiCounter, holder.transform.GetChild(0).transform.position, holder.transform.GetChild(0).transform.rotation) as GameObject;
            //counter.transform.SetParent(holder.transform);
            counter.transform.localEulerAngles = Vector3.zero;
            counter.GetComponent<ParalelsCounter>().SetText("");
            counter.GetComponent<ParalelsCounter>().curve = true;
            centerCounter = counter.GetComponent<ParalelsCounter>();

            findFinish = true;
            Transform gm = GetClosestPoint(allPoints);
            if (gm != null)
            {
                trakedObject = gm.gameObject;
            }

            List<Vector3> pointsPos = new List<Vector3>();
            foreach(Transform t in holder)
            {
                pointsPos.Add(t.position);
            }
            curveSaver.Add(0, pointsPos);

            frontForward = holder.GetChild(holder.childCount - 1).forward;
            rearForward = holder.GetChild(0).forward;

            frontEuler = holder.GetChild(holder.childCount - 1).eulerAngles;
            rearEuler = holder.GetChild(0).eulerAngles;
        }

        SetLines(holder.gameObject);

        if (startingPos == null)
        {
            GameObject obj = new GameObject("startingPos");
            obj.transform.position = holder.transform.position;
            obj.transform.eulerAngles = holder.transform.eulerAngles;
            startingPos = obj;
        }

        float deltaa = ((float)MetricsWindow.Instance.metrics + (float)MetricsWindow.Instance.sm / 100) * 6.278354f;
        lastDeltaa = deltaa;
        deltaLast = ((float)MetricsWindow.Instance.metrics + (float) MetricsWindow.Instance.sm / 100f);

        if (holder.GetChild(holder.childCount - 1).localPosition.x < 0)
        {
            //deltaLast *= -1;
        }
        GameObject lastPart = null;

        for (int i = 0; i < holder.transform.childCount - 2; i++)
        {
            Transform tempTransform = holder.transform.GetChild(i);
            tempTransform.LookAt(holder.transform.GetChild(i + 1));
        }

        /*if (testPoints.Count == 0)
        {
            foreach(Transform tr in holder.transform)
            {
                testPoints.Add(tr.position);
            }
        }*/



        for (int i = 0; i < 1; i++)
        {
            GameObject obj = CreateLines(holder.gameObject, startingPos.transform, deltaa * (i + 1), countDelta + i + 1, lastPart, countDelta + i + 1);
            /* GameObject counter = GameObject.Instantiate(uiCounter, obj.transform.GetChild(0).transform.position, obj.transform.GetChild(0).transform.rotation) as GameObject;
             //counter.transform.SetParent(obj.transform);
             counter.transform.localEulerAngles = Vector3.zero;
             counter.GetComponent<ParalelsCounter>().SetText(countDelta + i+1);
             counter.GetComponent<ParalelsCounter>().curve = true;
             counters.Add(counter.GetComponent<ParalelsCounter>());
             obj.GetComponent<CurveCounter>().side = CurveSide.Right; */
            lastPart = obj;
        }
        lastPart = null;
        for (int i = 0; i < 1; i++)
        {
            GameObject obj = CreateLines(holder.gameObject, startingPos.transform, deltaa * -(i + 1), countDelta - (i + 1), lastPart,countDelta - (i + 1));
            /*GameObject counter = GameObject.Instantiate(uiCounter, obj.transform.GetChild(0).transform.position, obj.transform.GetChild(0).transform.rotation) as GameObject;
            //counter.transform.SetParent(obj.transform);
            counter.transform.localEulerAngles = Vector3.zero;
            counter.GetComponent<ParalelsCounter>().SetText(countDelta - (i+1));
            counter.GetComponent<ParalelsCounter>().curve = true;
            counters.Add(counter.GetComponent<ParalelsCounter>());*/
            obj.GetComponent<CurveCounter>().side = CurveSide.Left;
            lastPart = obj;
        }

        CheckLines();
        //CheckForTrigger();
        IndicatorPanel.Instance.gameObject.SetActive(true);
        TogglesPanel.Instance.gameObject.SetActive(true);
        RightPanel.Instance.SetABFalse();
        SetMaterials();
        curveCount = points.Count / 3;
        //DrawCurve();
        Transform gmm = GetClosestPoint(allPoints);
        if (gmm != null)
        {
            trakedObject = gmm.gameObject;
        }
    }

    private void CheckLines()
    {
        foreach (GameObject obj in holders)
        {
            List<GameObject> toDel = new List<GameObject>();

            for (int i = 0; i < obj.transform.childCount; i++)
            {

                for (int j = holders.Count - 1; j >= 0; j--)
                {
                    if(holders[j] != obj)
                    for (int k = 0; k < holders[j].transform.childCount; k++)
                    {
                        if (Vector3.Distance(obj.transform.GetChild(i).position, holders[j].transform.GetChild(k).position) < lastDeltaa * 0.99f)
                        {
                            toDel.Add(obj.transform.GetChild(i).gameObject);
                        }
                    }
                }
            }


            for (int i = 0; i < obj.transform.childCount; i++)
            {

                for (int j = 0; j < holder.childCount; j++)
                {
                    if (Vector3.Distance(obj.transform.GetChild(i).position, holder.GetChild(j).position) < lastDeltaa * 0.99f)
                    {
                        toDel.Add(obj.transform.GetChild(i).gameObject);
                    }

                }
            }


            foreach (GameObject go in toDel)
            {
                go.transform.SetParent(null);
                Destroy(go);
            }
            toDel.Clear();



            try
            {
                if (holder.childCount / obj.transform.childCount >= 2)
                {
                    obj.SetActive(false);
                }
            }
            catch (Exception ex)
            {
                obj.SetActive(false);
            }
        }


        foreach (GameObject obj in holders)
        {
            SetLines(obj);
        }
    }

    private void CheckForTrigger()
    {
        GameObject holderLeft = holders[0];
        GameObject holderRight = holders[1];

        GameObject leftRear = holderLeft.transform.GetChild(0).gameObject;
        GameObject leftFront = holderLeft.transform.GetChild(holderLeft.transform.childCount - 1).gameObject;

        GameObject rightRear = holderRight.transform.GetChild(0).gameObject;
        GameObject rightFront = holderRight.transform.GetChild(holderRight.transform.childCount - 1).gameObject;

        //leftRear.transform.eulerAngles = rearEuler;
        //rightRear.transform.eulerAngles = rearEuler;

        //leftFront.transform.eulerAngles = frontEuler;
        //rightFront.transform.eulerAngles = frontEuler;

        RaycastHit hit = new RaycastHit();

        Debug.DrawRay(leftRear.transform.position + (-leftRear.transform.forward) , -leftRear.transform.forward * lastDeltaa, Color.blue, 15);
        Debug.DrawRay(rightRear.transform.position + (-rightRear.transform.forward), -rightRear.transform.forward * lastDeltaa, Color.blue, 15);
        Debug.DrawRay(leftFront.transform.position + leftFront.transform.forward, leftFront.transform.forward * lastDeltaa, Color.blue, 15);
        Debug.DrawRay(rightFront.transform.position + rightFront.transform.forward, rightFront.transform.forward * lastDeltaa, Color.blue, 15);

        //Rear
        if (Physics.Raycast(new Ray(leftRear.transform.position+(-leftRear.transform.forward), -leftRear.transform.forward * lastDeltaa),out hit))
        {
            if(hit.collider.tag != "Curves" || hit.collider.transform.parent == holder)
            {
                SetCollider(leftRear, 5000, -2500, holder.GetChild(0).eulerAngles);
            }
            else
            {
                SetCollider(leftRear, -hit.distance, -hit.distance / 2, holder.GetChild(0).eulerAngles);
            }
        }
        else
        {
            SetCollider(leftRear, 5000, -2500, holder.GetChild(0).eulerAngles);
        }

        if (Physics.Raycast(new Ray(rightRear.transform.position+ (-rightRear.transform.forward), -rightRear.transform.forward * lastDeltaa), out hit))
        {
            if (hit.collider.tag != "Curves" || hit.collider.transform.parent == holder)
            {
                SetCollider(rightRear, 5000, -2500, holder.GetChild(0).eulerAngles);
            }
            else
            {
                SetCollider(rightRear, -hit.distance, -hit.distance / 2, holder.GetChild(0).eulerAngles);
            }
        }
        else
        {
            SetCollider(rightRear, 5000, -2500, holder.GetChild(0).eulerAngles);
        }


        //Front
        if (Physics.Raycast(new Ray(leftFront.transform.position + leftFront.transform.forward, leftFront.transform.forward * lastDeltaa), out hit))
        {
            if (hit.collider.tag != "Curves" || hit.collider.transform.parent == holder)
            {
                SetCollider(leftFront, 5000, 2500, holder.GetChild(holder.childCount - 1).eulerAngles);
            }
            else
            {
                SetCollider(leftFront, hit.distance, hit.distance / 2, holder.GetChild(holder.childCount - 1).eulerAngles);
            }
        }
        else
        {
            SetCollider(leftFront, 5000, 2500, holder.GetChild(holder.childCount - 1).eulerAngles);
        }

        if (Physics.Raycast(new Ray(rightFront.transform.position+ rightFront.transform.forward, rightFront.transform.forward * lastDeltaa), out hit))
        {
            if (hit.collider.tag != "Curves" || hit.collider.transform.parent == holder)
            {
                SetCollider(rightFront, 5000, 2500, holder.GetChild(holder.childCount - 1).eulerAngles);
            }
            else
            {
                SetCollider(rightFront, hit.distance, hit.distance / 2, holder.GetChild(holder.childCount - 1).eulerAngles);
            }
        }
        else
        {
            SetCollider(rightFront, 5000, 2500, holder.GetChild(holder.childCount - 1).eulerAngles);
        }
    }

    private void SetCollider(GameObject obj, float size, float offset, Vector3 eulerAngles)
    {
        BoxCollider col = obj.AddComponent<BoxCollider>();
        obj.GetComponent<BoxCollider>().isTrigger = true;
        col.isTrigger = true;
        col.size = new Vector3(4, 1,size);
        col.center = new Vector3(0, 0, offset);
        //obj.transform.eulerAngles = eulerAngles;
    }


    public void SetMaterials()
    {
        for (int i = 0; i < holders.Count; i++)
        {
            if(holders[i].activeSelf)
                holders[i].transform.GetChild(0).GetComponent<LineRenderer>().material = sideLineMaterial;
        }
        holder.transform.GetChild(0).GetComponent<LineRenderer>().material = lineMaterial;
    }

    public List<CRSpline> spines;


    private GameObject CreateLines(GameObject hold, Transform po, float delta = 0, int index = 0, GameObject lastPart = null, int positiveIndex = 0)
    {
        List<Vector3> pointsPos = new List<Vector3>();
        GameObject obj = new GameObject("Curve" + index);// GameObject.Instantiate(hold) as GameObject;
        obj.AddComponent<CurveCounter>();
        obj.transform.localScale = new Vector3(1, 1, 1);

        if (curveSaver.ContainsKey(index))
        {
            pointsPos = curveSaver[index];
            for(int i = 0; i < pointsPos.Count; i++)
            {
                GameObject tempPoint = Instantiate(pointPrefab);
                tempPoint.tag = "Curves";
                    tempPoint.transform.position = pointsPos[i];
                tempPoint.transform.SetParent(obj.transform);
            }

            for (int i = 0; i < obj.transform.childCount - 2; i++)
            {
                Transform tempTransform = obj.transform.GetChild(i);
                tempTransform.LookAt(obj.transform.GetChild(i + 1));
            }

            for (int i = 0; i < obj.transform.childCount; i++)
            {
                if (i + 1 < obj.transform.childCount && obj.transform.GetChild(i + 1).gameObject.activeSelf && i != 0)
                {
                    GameObject obj1 = obj.transform.GetChild(i).gameObject;
                    GameObject obj2 = obj.transform.GetChild(i + 1).gameObject;

                    obj1.transform.LookAt(obj2.transform);

                    if (obj1.GetComponent<BoxCollider>() != null)
                        Destroy(obj1.GetComponent<BoxCollider>());

                    if (i < obj.transform.childCount - 1)
                    {
                        BoxCollider col = obj1.AddComponent<BoxCollider>();
                        obj1.GetComponent<BoxCollider>().isTrigger = true;
                        col.isTrigger = true;
                        col.size = new Vector3(4, 1, Vector3.Distance(obj1.transform.position, obj2.transform.position) - 0.1f);
                        col.center = new Vector3(0, 0, Vector3.Distance(obj1.transform.position, obj2.transform.position) / 2 - 0.05f);
                    }

                }
                /*if (i == obj.transform.childCount - 1)
                {
                    GameObject objj = obj.transform.GetChild(i).gameObject;
                    BoxCollider col = objj.AddComponent<BoxCollider>();
                    objj.GetComponent<BoxCollider>().isTrigger = true;
                    col.isTrigger = true;
                    col.size = new Vector3(4, 1, 50000);
                    col.center = new Vector3(0, 0, 50000 / 2);
                }
                if (i == 0)
                {
                    GameObject objj = obj.transform.GetChild(i).gameObject;
                    BoxCollider col = objj.AddComponent<BoxCollider>();
                    objj.GetComponent<BoxCollider>().isTrigger = true;
                    col.isTrigger = true;
                    col.size = new Vector3(4, 1, 50000);
                    col.center = new Vector3(0, 0, -50000 / 2);
                }*/



            }

            foreach(Transform t in holder)
            {
                SavePoint(t.gameObject);
            }
        }
        else
        {

            float deltaa = ((float)MetricsWindow.Instance.metrics + (float)MetricsWindow.Instance.sm / 100) * 6.278354f;

            for (int i = 0; i < holder.transform.childCount; i++)
            {

                Transform tempTransform = holder.GetChild(i);
                if (!tempTransform.name.StartsWith("Paralels"))
                {
                    GameObject tempPoint = Instantiate(tempTransform.gameObject);
                    tempPoint.tag = "Curves";
                    Vector3 tempPos = Vector3.zero;
                    int vectCount = 0;

                    if (i == 0)
                    {
                        tempPoint.transform.position = holder.transform.GetChild(0).position + holder.transform.GetChild(0).right * (delta);
                        obj.transform.position = tempPoint.transform.position;
                    }
                    else
                    {
                        tempPoint.transform.position = holder.transform.GetChild(i).position + holder.transform.GetChild(i).right * (delta);
                    }

                    tempPoint.transform.SetParent(obj.transform);
                }
            }

            List<GameObject> toDel = new List<GameObject>();

            for (int i = 0; i < obj.transform.childCount; i++)
            {

                for (int j = 0; j < holders.Count; j++)
                {
                    for (int k = 0; k < holders[j].transform.childCount; k++)
                    {
                        if (Vector3.Distance(obj.transform.GetChild(i).position, holders[j].transform.GetChild(k).position) < deltaa * 0.99f)
                        {
                            toDel.Add(obj.transform.GetChild(i).gameObject);
                        }
                    }
                }
            }


            for (int i = 0; i < obj.transform.childCount; i++)
            {

                for (int j = 0; j < holder.childCount; j++)
                {
                    if (Vector3.Distance(obj.transform.GetChild(i).position, holder.GetChild(j).position) < deltaa * 0.99f)
                    {
                        toDel.Add(obj.transform.GetChild(i).gameObject);
                    }

                }
            }


            foreach (GameObject go in toDel)
            {
                go.transform.SetParent(null);
                Destroy(go);
            }
            toDel.Clear();

            for (int i = 0; i < obj.transform.childCount; i++)
            {
                for (int j = 0; j < obj.transform.childCount ; j++)
                {
                    GameObject obj1 = obj.transform.GetChild(i).gameObject;
                    GameObject obj2 = obj.transform.GetChild(j).gameObject;
                    obj1.transform.LookAt(obj2.transform);
                    if (i != j && Vector3.Distance(obj.transform.GetChild(i).position, obj.transform.GetChild(j).position) < MinDist)
                    {
                        //obj.transform.GetChild(i).SetParent(obj.transform.GetChild(j));
                        toDel.Add(obj.transform.GetChild(i).gameObject);
                    }
                }

            }
            foreach (GameObject go in toDel)
            {
                go.transform.SetParent(null);
                Destroy(go);
            }
            toDel.Clear();


            for (int i = 0; i < obj.transform.childCount; i++)
            {
                if (i + 1 < obj.transform.childCount && obj.transform.GetChild(i + 1).gameObject.activeSelf)
                {
                    GameObject obj1 = obj.transform.GetChild(i).gameObject;
                    GameObject obj2 = obj.transform.GetChild(i + 1).gameObject;

                    obj1.transform.LookAt(obj2.transform);

                    if (obj1.GetComponent<BoxCollider>() != null)
                        Destroy(obj1.GetComponent<BoxCollider>());

                    if (i < obj.transform.childCount - 1)
                    {
                        BoxCollider col = obj1.AddComponent<BoxCollider>();
                        obj1.GetComponent<BoxCollider>().isTrigger = true;
                        col.isTrigger = true;
                        col.size = new Vector3(4, 1, Vector3.Distance(obj1.transform.position, obj2.transform.position) - 0.1f);
                        col.center = new Vector3(0, 0, Vector3.Distance(obj1.transform.position, obj2.transform.position) / 2 - 0.05f);
                    }

                }

                SavePoint(obj.transform.GetChild(i).gameObject);
                pointsPos.Add(obj.transform.GetChild(i).position);
            }


        }

        try
        {
            if (hold.transform.childCount / obj.transform.childCount >= 3)
            {
                obj.SetActive(false);
                Debug.Log("SetActive false index:" + index);
            }
        }
        catch (Exception ex)
        {
            obj.SetActive(false);
            Debug.Log("SetActive false index:" + index);
        }

        if(!curveSaver.ContainsKey(index) && obj.activeSelf)
        {
            curveSaver.Add(index, pointsPos);
        }

        holders.Add(obj);
        //SetLines(obj);
        return obj;
    }

    private float lastScale = 1;

    Transform forRotate = null;
    bool findFinish = false;
    GameObject lastObj = null;

    private float MinDist = 4f;

    private void SetLines(GameObject hold)
    {
        try
        {
            if (!hold.gameObject.activeSelf)
            {
                return;
            }

            lastObj = null;
            int k = 0;
            for (int i = 0; i < hold.transform.childCount; i++)
            {
                if (hold.transform.GetChild(i).gameObject.activeSelf)
                {
                    lastObj = hold.transform.GetChild(i).gameObject;
                    k = i;
                }

            }
            hold.transform.GetChild(hold.transform.childCount - 2).LookAt(hold.transform.GetChild(hold.transform.childCount - 1));

            hold.transform.GetChild(0).LookAt(hold.transform.GetChild(1));
            hold.transform.GetChild(hold.transform.childCount - 1).eulerAngles = hold.transform.GetChild(0).eulerAngles;
            hold.transform.GetChild(hold.transform.childCount - 1).eulerAngles = hold.transform.GetChild(hold.transform.childCount - 2).eulerAngles;
            //lastObj.transform.eulerAngles = hold.transform.GetChild(0).eulerAngles;
            LineRenderer renderer = hold.transform.GetChild(0).GetComponent<LineRenderer>();
            if (renderer == null)
                renderer = hold.transform.GetChild(0).gameObject.AddComponent<LineRenderer>();//.GetComponent<LineRenderer>();

            renderer.positionCount = hold.transform.childCount;
            renderer.material = lineMaterial;
            renderer.endWidth = 1.5f;
            renderer.startWidth = 1.5f;

            if (CheckWorkType.Instance.typeId == 8)
            {
                renderer.endWidth = 1.5f * 3;
                renderer.startWidth = 1.5f * 3;
            }

            if (firstTime)
            {
                //hold.transform.GetChild(0).position = hold.transform.GetChild(0).position - hold.transform.GetChild(0).forward * 50000;
                hold.transform.GetChild(0).LookAt(hold.transform.GetChild(1));
                for (int i = 0; i < hold.transform.childCount; i++)
                {

                    renderer.SetPosition(i, hold.transform.GetChild(i).position);

                }
            }
            else
            {
                for (int i = 0; i < hold.transform.childCount; i++)
                {

                    renderer.SetPosition(i, hold.transform.GetChild(i).position);

                }
            }

            if (!findFinish)
            {
                //hold.transform.GetChild(hold.transform.childCount - 1).position = hold.transform.GetChild(hold.transform.childCount - 1).position + hold.transform.GetChild(hold.transform.childCount - 1).forward * 10000;
            }
            //renderer.SetPosition(hold.transform.childCount - 1, hold.transform.GetChild(hold.transform.childCount - 1).position);
        }
        catch { }
    }

    public void StartTracking()
    {
        if (PlayerPrefs.GetInt("VelestorDevice") == 1)
        {
            tracking = true;
            RightPanel.Instance.OnABClick();
            aButton.interactable = false;
        }
        else
        {
            MainGUI.Instance.StartShowCantOpen();
        }

    }

    // For tracking

    public void SetTrackedTarget(GameObject obj)
    {
        foreach (GameObject objj in holders)
        {
            for (int i = 0; i < objj.transform.childCount; i++)
            {
                if (objj.transform.GetChild(i).gameObject == obj)
                {
                    if (i + 1 < objj.transform.childCount)
                    {
                        trakedObject = objj.transform.GetChild(i + 1).gameObject;
                    }
                    else
                    {
                        trakedObject = objj.transform.GetChild(i).gameObject;
                    }
                    break;
                }
            }
        }
    }

    Transform GetClosestPoint(List<Transform> enemies)
    {
        Transform tMin = null;
        float minDist = Mathf.Infinity;
        Vector3 currentPos = transform.position;
        foreach (Transform t in enemies)
        {
            if (t != null && t.name != "ParalelsCounter(Clone)")
            {
                float dist = Vector3.Distance(t.position, tractor.position);
                if (dist < minDist)
                {
                    tMin = t;
                    minDist = dist;
                }
            }
        }

        if (tMin == null && allPoints.Count > 0)
            return allPoints[0];
        return tMin;
    }

    Transform GetClosestPointByDistance(List<Transform> enemies)
    {
        Transform tMin = null;
        float minDist = Mathf.Infinity;
        Vector3 currentPos = transform.position;
        foreach (Transform t in enemies)
        {
            if (t != null && t.name != "ParalelsCounter(Clone)")
            {
                float dist = Vector3.Distance(t.position, tractor.position);
                if (dist < minDist)
                {
                    tMin = t;
                    minDist = dist;
                }
            }
        }

        if (tMin == null && allPoints.Count > 0)
            return allPoints[0];
        return tMin;
    }

    bool FrontTest(Transform otherTransform)
    {
        Vector3 fwd = TractorController.Instance.transform.forward;
        Vector3 vec = otherTransform.position - TractorController.Instance.transform.position;
        vec.Normalize();


        float ang = Mathf.Acos(Vector3.Dot(fwd, vec)) * Mathf.Rad2Deg;

        bool isFront = false;

        if (ang <= 35f)
            return true;

        return false;
    }

    public Vector3 Ortho(Vector3 v1, Vector3 v2, Vector3 v3)
    {
        // Длины отрезков.
        var c = Math.Sqrt(Math.Pow(v1.x - v2.x, 2) + Math.Pow(v1.y - v2.y, 2) + Math.Pow(v1.z - v2.z, 2));
        var b = Math.Sqrt(Math.Pow(v2.x - v3.x, 2) + Math.Pow(v2.y - v3.y, 2) + Math.Pow(v2.z - v3.z, 2));
        var a = Math.Sqrt(Math.Pow(v3.x - v1.x, 2) + Math.Pow(v3.y - v1.y, 2) + Math.Pow(v3.z - v1.z, 2));

        // Полупериметр треугольника.
        var p = (a + b + c) / 2;
        // Высота (длина перпендикуляра).
        var h = 2 * Math.Sqrt(p * (p - a) * (p - b) * (p - c)) / c;

        float x, y, z = 0;

        if (a / c > b / c)
        {
            var c1 = Math.Sqrt(a * a - h * h);
            float k = (float)c1 / (float)c;
            x = v1.x + (float)k * (v2.x - v1.x);
            y = v1.y + k * (v2.y - v1.y);
            z = v1.z + k * (v2.z - v1.z);
        }
        else
        {
            var c2 = Math.Sqrt(b * b - h * h);
            float k = (float)c2 / (float)c;
            x = v2.x + k * (v1.x - v2.x);
            y = v2.y + k * (v1.y - v2.y);
            z = v2.z + k * (v1.z - v2.z);
        }

        return new Vector3(x, y, z);
    }

    private List<Transform> GetNearestPoints()
    {
        List<Transform> p = new List<Transform>();

        int index = allPoints.IndexOf(trakedObject.transform);
        if (index > 0)
        {
            p.Add(allPoints[index - 1]);
        }
        else
        {
            p.Add(allPoints[index]);
        }

        if (index != allPoints.Count - 1)
        {
            p.Add(allPoints[index + 1]);
        }
        else
        {
            p.Add(allPoints[index]);
        }

        return p;
    }

    private List<Transform> GetNearestPointsByPoint(Vector3 pos)
    {
        List<Transform> p = new List<Transform>();

        float minDist = 999;
        Transform nearestTransform = null;

        foreach (Transform t in holder.transform)
        {
            float dist = Vector3.Distance(t.position, pos);
            if(dist < minDist)
            {
                minDist = dist;
                nearestTransform = t;
            }
        }

        int index = allPoints.IndexOf(nearestTransform);

        if(index == -1)
        {
            return p;
        }

        if (index > 0)
        {
            p.Add(allPoints[index - 1]);
        }
        else
        {
            p.Add(allPoints[index]);
        }

        if (index != allPoints.Count - 1)
        {
            p.Add(allPoints[index + 1]);
        }
        else
        {
            p.Add(allPoints[index]);
        }

        return p;
    }

    private float GetNearestDistanceByPoint(Vector3 pos)
    {
        List<Transform> p = new List<Transform>();

        float minDist = 999;

        foreach (Transform t in holder.transform)
        {
            float dist = Vector3.Distance(t.position, pos);
            if (dist < minDist)
            {
                minDist = dist;
            }
        }
        return minDist;
    }

    void SpawnFirstPoint()
    {
        Transform tempTransform = holder.transform.GetChild(0);
        GameObject tempPoint = Instantiate(tempTransform.gameObject);
        tempPoint.name = "TestPoint";
        tempPoint.transform.position = holder.transform.GetChild(0).position + holder.transform.GetChild(0).right * lastDeltaa;
    }

    Vector3 FindIntersection(Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4)
    {
        float xD1, yD1, xD2, yD2, xD3, yD3;
        float dot, deg, len1, len2;
        float segmentLen1, segmentLen2;
        float ua, ub, div;

        // calculate differences
        xD1 = p2.x - p1.x;
        xD2 = p4.x - p3.x;
        yD1 = p2.y - p1.y;
        yD2 = p4.y - p3.y;
        xD3 = p1.x - p3.x;
        yD3 = p1.y - p3.y;

        // calculate the lengths of the two lines
        len1 = Mathf.Sqrt(xD1 * xD1 + yD1 * yD1);
        len2 = Mathf.Sqrt(xD2 * xD2 + yD2 * yD2);

        // calculate angle between the two lines.
        dot = (xD1 * xD2 + yD1 * yD2); // dot product
        deg = dot / (len1 * len2);

        // if abs(angle)==1 then the lines are parallell,
        // so no intersection is possible
        if (Mathf.Abs(deg) == 1) return Vector3.zero;

        // find intersection Pt between two lines
        Vector3 pt = new Vector3(0, 0, 0);
        div = yD2 * xD1 - xD2 * yD1;
        ua = (xD2 * yD3 - yD2 * xD3) / div;
        ub = (xD1 * yD3 - yD1 * xD3) / div;
        pt.x = p1.x + ua * xD1;
        pt.y = p1.y + ua * yD1;

        // calculate the combined length of the two segments
        // between Pt-p1 and Pt-p2
        xD1 = pt.x - p1.x;
        xD2 = pt.x - p2.x;
        yD1 = pt.y - p1.y;
        yD2 = pt.y - p2.y;
        segmentLen1 = Mathf.Sqrt(xD1 * xD1 + yD1 * yD1) + Mathf.Sqrt(xD2 * xD2 + yD2 * yD2);

        // calculate the combined length of the two segments
        // between Pt-p3 and Pt-p4
        xD1 = pt.x - p3.x;
        xD2 = pt.x - p4.x;
        yD1 = pt.y - p3.y;
        yD2 = pt.y - p4.y;
        segmentLen2 = Mathf.Sqrt(xD1 * xD1 + yD1 * yD1) + Mathf.Sqrt(xD2 * xD2 + yD2 * yD2);

        // if the lengths of both sets of segments are the same as
        // the lenghts of the two lines the point is actually
        // on the line segment.

        // if the point isn't on the line, return null
        if (Mathf.Abs(len1 - segmentLen1) > 0.01 || Mathf.Abs(len2 - segmentLen2) > 0.01)
            return Vector3.zero;

        // return the valid intersection
        return pt;
    }

    CRSpline RemoveLoopsFromSpline(CRSpline spline)
    {
        Vector3 intersection;
        bool intersected;
        List<Vector3> points = new List<Vector3>();
        for (int i = 0; i < spline.pts.Length - 1; i++)
        {
            intersected = false;
            for (int j = i + 2; j < spline.pts.Length - 1; j++)
            {
                // I didn't have a nice FindIntersections code so hacked together.
                // Returns Vector.zero when it can't find an intersection... obviously this
                // could cause issues. Should return a struct or class.
                // Good enough for illustrative purposes.
                intersection = FindIntersection(spline.pts[i], spline.pts[i + 1], spline.pts[j], spline.pts[j + 1]);
                if (intersection != Vector3.zero)
                {
                    intersected = true;
                    points.Add(spline.pts[i]);
                    points.Add(intersection);
                    i = j;
                    break;
                }
            }
            if (!intersected) points.Add(spline.pts[i]);
        }
        points.Add(spline.pts[spline.pts.Length - 1]);
        return new CRSpline(points.ToArray());
    }

    private void DrawLine(float lenght)
    {
        for (int i = 0; i < spines.Count; i++)
        {
            List<Vector3> newPos = new List<Vector3>();
            //debug draw bottom obstacle line
            for (int j = 0; j < spines[i].pts.Length; j++)
            {
                float fPos = (1.0f / (spines[i].pts.Length)) * j;

                Vector3 ptOnLine = spines[i].Interp(fPos);
                Vector3 direction = spines[i].Velocity(fPos);
                Vector3 sideways = Vector3.Cross(Vector3.up, direction).normalized;
                Vector3 v3Pos1 = ptOnLine - sideways * (lastDeltaa * lenght);

                fPos = (1.0f / (spines[i].pts.Length)) * (j + 1);

                ptOnLine = spines[i].Interp(fPos);
                direction = spines[i].Velocity(fPos);
                sideways = Vector3.Cross(Vector3.up, direction).normalized;
                Vector3 v3Pos2 = ptOnLine - sideways * (lastDeltaa * lenght);

                newPos.Add(new Vector3(v3Pos1.x,0.5f, v3Pos1.z));
            }
            CRSpline spline = new CRSpline(newPos.ToArray());
            spline = RemoveLoopsFromSpline(spline);
            spline = RemoveLoopsFromSpline(spline);
            spline = RemoveLoopsFromSpline(spline);
            spline = RemoveLoopsFromSpline(spline);
            spline = RemoveLoopsFromSpline(spline);
            for (int j = 0; j < spline.pts.Length - 1; j++)
            {
                Debug.DrawLine(spline.pts[j], spline.pts[j + 1], Color.blue, 3);
            }
        }
    }

    private GameObject GetNearestHolder()
    {
        GameObject nearestHolder = null;
        float minDistance = 9999;

        for (int i = 0; i <= 1; i++)
        {
            foreach (Transform t in holders[i].transform)
            {
                float tempDist = Vector3.Distance(TractorController.Instance.trailer[0].transform.position, t.position);
                if (tempDist < minDistance)
                {
                    minDistance = tempDist;
                    nearestHolder = t.parent.gameObject;
                }
            }
        }

        return nearestHolder;
    }

    private void CheckForRebuildLines(List<Transform> nearestPoints,Vector3 ortho)
    {
        Transform forwardPoint = holder.GetChild(holder.childCount - 1);
        Transform rearPoint = holder.GetChild(0);

        if (nearestPoints[0] != forwardPoint && nearestPoints[1] != forwardPoint &&
            nearestPoints[0] != rearPoint && nearestPoints[1] != rearPoint)
        {
            if (Vector3.Distance(ortho, TractorController.Instance.trailer[0].transform.position) > lastDeltaa)
            {
                ResetCurves(GetNearestHolder());
            }
        }else if (nearestPoints[0] == forwardPoint || nearestPoints[1] == forwardPoint)
        {
            Transform leftPoint = holders[0].transform.GetChild(holders[0].transform.childCount - 1);
            Transform rightPoint = holders[1].transform.GetChild(holders[1].transform.childCount - 1);
            float leftDistance = Vector3.Distance(leftPoint.position, TractorController.Instance.trailer[0].transform.position);
            float rightDistance = Vector3.Distance(rightPoint.position, TractorController.Instance.trailer[0].transform.position);
            float forwardDistance = Vector3.Distance(forwardPoint.position, TractorController.Instance.trailer[0].transform.position);

            if(forwardDistance < lastDeltaa * 2)
            {
                return;
            }

            if (leftDistance < forwardDistance)
            {
                ResetCurves(leftPoint.parent.gameObject);
            }
            else if (rightDistance < forwardDistance)
            {
                ResetCurves(rightPoint.parent.gameObject);
            }
        }
        else if (nearestPoints[0] == rearPoint || nearestPoints[1] == rearPoint)
        {
            Transform leftPoint = holders[0].transform.GetChild(0);
            Transform rightPoint = holders[1].transform.GetChild(0);
            float leftDistance = Vector3.Distance(leftPoint.position, TractorController.Instance.trailer[0].transform.position);
            float rightDistance = Vector3.Distance(rightPoint.position, TractorController.Instance.trailer[0].transform.position);
            float rearDistance = Vector3.Distance(rearPoint.position, TractorController.Instance.trailer[0].transform.position);

            if (rearDistance < lastDeltaa * 2)
            {
                return;
            }

            if (leftDistance < rearDistance && leftPoint != null && leftPoint.parent != null && leftPoint.parent.gameObject != null)
            {
                ResetCurves(leftPoint.parent.gameObject);
            }
            else if (rightDistance < rearDistance && rightPoint != null && rightPoint.parent != null && rightPoint.parent.gameObject != null)
            {
                ResetCurves(rightPoint.parent.gameObject);
            }
        }
    }

    void Update()
    {

        if (tracking && aButton.interactable == false && points.Count > 0)
        {
            if (Vector3.Distance(points[0].transform.position, TractorController.Instance.trailer[0].transform.position) / 6.27f >
                30)
            {
                aButton.interactable = true;
            }
        }

        if (trakedObject == null)
        {
            if (findFinish)
            {
                Transform gm = GetClosestPoint(allPoints);
                if (gm != null)
                {
                    trakedObject = gm.gameObject;
                }
            }
            return;
        }

        if (tracking == false && holders.Count > 0)
        {
            Transform gm = GetClosestPoint(allPoints);
            if (gm != null)
            {
                trakedObject = gm.gameObject;
            }
        }
        CheckDistance();
        List<Transform> nearestPoints = GetNearestPoints();

        Vector3 ontho = Ortho(nearestPoints[0].position, nearestPoints[1].position, TractorController.Instance.trailer[0].transform.position + TractorController.Instance.trailer[0].transform.forward * 10);
        Vector3 ontho2 = Ortho(nearestPoints[0].position, nearestPoints[1].position, TractorController.Instance.trailer[0].transform.position + TractorController.Instance.trailer[0].transform.forward * 50);

        Vector3 ortho = Ortho(nearestPoints[0].position, nearestPoints[1].position, TractorController.Instance.trailer[0].transform.position);

        try
        {
            CheckForRebuildLines(nearestPoints, ortho);
        }
        catch { }

        if (centerCounter != null)
        {
            centerCounter.transform.position = new Vector3(ontho2.x, centerCounter.transform.position.y, ontho2.z);
        }
        //centerCounter.transform.localPosition = new Vector3(trakedObject.transform.localPosition.x, centerCounter.transform.localPosition.y, centerCounter.transform.localPosition.z);
        for (int i = 0; i < counters.Count; i++)
        {
            if (i < 3)
            {
                if(centerCounter != null)
                    counters[i].transform.localPosition = centerCounter.transform.localPosition + (Vector3.forward * (-deltaLast * (i+1)));
            }
            else
            {
                if (centerCounter != null)
                    counters[i].transform.localPosition = centerCounter.transform.localPosition + (Vector3.forward * (deltaLast * (i - 3 + 1)));

            }
        }

        Vector3 targetPostition = new Vector3(ontho.x,
                                        TractorController.Instance.Arrow.transform.transform.position.y,
                                        ontho.z);

        TractorController.Instance.Arrow.transform.LookAt(targetPostition);
        bool forward = true;
        if ((TractorController.Instance.Arrow.transform.localEulerAngles.y < 100 && TractorController.Instance.Arrow.transform.localEulerAngles.y > -100) ||
            (TractorController.Instance.Arrow.transform.localEulerAngles.y > 240 || TractorController.Instance.Arrow.transform.localEulerAngles.y < -240))
        {
            IndicatorPanel.Instance.SetArrowRotation(new Vector3(0, 0, -TractorController.Instance.Arrow.transform.localEulerAngles.y));
            //arrow.localEulerAngles = new Vector3(0, 0, -TractorController.Instance.Arrow.transform.localEulerAngles.y);
        }
        else
        {
            forward = false;
            IndicatorPanel.Instance.SetArrowRotation(new Vector3(0, 0, 180 - TractorController.Instance.Arrow.transform.localEulerAngles.y));
            //arrow.localEulerAngles = ;
        }

        IndicatorPanel.Instance.SetIndicators(TractorController.Instance.Arrow.transform.localEulerAngles.y, forward);

    }

    private void CheckDistance()
    {
        List<Transform> nearestPoints = GetNearestPoints();
        Vector3 onthoo = Ortho(nearestPoints[0].position, nearestPoints[1].position, tractor.position);
        if (trakedObject != null)
        {
            //Vector3 ontho = Ortho(trakedObject.transform.position - trakedObject.transform.forward * 10000, trakedObject.transform.position + trakedObject.transform.forward * 10000, TractorController.Instance.transform.position + TractorController.Instance.transform.forward * 10);
            float dist = Vector3.Distance(onthoo, tractor.position) / 6.278354f;
            //dist -= dist / 5;

            //double metrics = Math.Round(((dist) * 2), 2);
            double metrics = Math.Round(dist,2);
            if(dist > (float)MetricsWindow.Instance.metrics + ((float)(MetricsWindow.Instance.sm / 100)))
            {
                trakedObject =  GetClosestPointByDistance(allPoints).gameObject;
                nearestPoints = GetNearestPoints();
                onthoo = Ortho(nearestPoints[0].position, nearestPoints[1].position, tractor.position);
                dist = Vector3.Distance(onthoo, tractor.position) / 6.278354f;

                if (dist > (float)MetricsWindow.Instance.metrics + ((float)(MetricsWindow.Instance.sm / 100)))
                {
                    trakedObject = GetClosestPointByDistance(allPoints).gameObject;
                    dist = Vector3.Distance(trakedObject.transform.position, tractor.position) / 6.278354f;
                }

                if (dist > (float)MetricsWindow.Instance.metrics + ((float)(MetricsWindow.Instance.sm / 100)))
                {
                    dist = ((float)MetricsWindow.Instance.metrics + ((float)(MetricsWindow.Instance.sm / 100)));
                }

                    metrics = Math.Round(dist, 2);
            }
            metricsText.text = metrics.ToString();
            IndicatorPanel.Instance.SetDistance(metrics);
        }
    }









    //Beizer
    private int curveCount = 0;
    private int layerOrder = 0;
    private int SEGMENT_COUNT = 20;
    public LineRenderer lineRenderer;

    void DrawCurve()
    {
        for (int j = 0; j < curveCount - 1; j++)
        {
            for (int i = 1; i <= SEGMENT_COUNT; i++)
            {
                float t = i / (float)SEGMENT_COUNT;
                int nodeIndex = j * 3;
                Vector3 pixel = CalculateCubicBezierPoint(t, points[nodeIndex].transform.position, points[nodeIndex + 1].transform.position, points[nodeIndex + 2].transform.position, points[nodeIndex + 3].transform.position);
                lineRenderer.positionCount = (((j * SEGMENT_COUNT) + i));
                lineRenderer.SetPosition((j * SEGMENT_COUNT) + (i - 1), pixel);
            }
        }

        lineRenderer.positionCount = lineRenderer.positionCount + 2;
        lineRenderer.SetPosition(lineRenderer.positionCount - 2, points[points.Count - 2].transform.position);
        lineRenderer.SetPosition(lineRenderer.positionCount - 1, points[points.Count - 1].transform.position);
    }
    Vector3 CalculateCubicBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
    {
        float u = 1 - t;
        float tt = t * t;
        float uu = u * u;
        float uuu = uu * u;
        float ttt = tt * t;
        Vector3 p = uuu * p0;
        p += 3 * uu * t * p1;
        p += 3 * u * tt * p2;
        p += ttt * p3;
        return p;
    }


    List<Vector3> GetDrawingPoints()
    {
        List<Vector3> drawingPoints = new List<Vector3>();
        for (int i = 0; i < points.Count - 3; i += 3)
        {
            Vector3 p0 = points[i].transform.position;
            Vector3 p1 = points[i + 1].transform.position;
            Vector3 p2 = points[i + 2].transform.position;
            Vector3 p3 = points[i + 3].transform.position;

            if (i == 0) //Only do this for the first endpoint.
                        //When i != 0, this coincides with the end
                        //point of the previous segment
            {
                drawingPoints.Add(CalculateCubicBezierPoint(0, p0, p1, p2, p3));
            }

            for (int j = 1; j <= SEGMENT_COUNT; j++)
            {
                float t = j / (float)SEGMENT_COUNT;
                drawingPoints.Add(CalculateCubicBezierPoint(t, p0, p1, p2, p3));
            }
        }

        return drawingPoints;
    }

}

[System.Serializable]
public class CRSpline
{
    public Vector3[] pts;

    public CRSpline(params Vector3[] pts)
    {
        this.pts = new Vector3[pts.Length];
        System.Array.Copy(pts, this.pts, pts.Length);
    }


    public Vector3 Interp(float t)
    {
        int numSections = pts.Length - 3;
        int currPt = Mathf.Min(Mathf.FloorToInt(t * (float)numSections), numSections - 1);
        float u = t * (float)numSections - (float)currPt;

        Vector3 a = pts[currPt];
        Vector3 b = pts[currPt + 1];
        Vector3 c = pts[currPt + 2];
        Vector3 d = pts[currPt + 3];

        return .5f * (
            (-a + 3f * b - 3f * c + d) * (u * u * u)
            + (2f * a - 5f * b + 4f * c - d) * (u * u)
            + (-a + c) * u
            + 2f * b
        );
    }


    public Vector3 Velocity(float t)
    {
        int numSections = pts.Length - 3;
        int currPt = Mathf.Min(Mathf.FloorToInt(t * (float)numSections), numSections - 1);
        float u = t * (float)numSections - (float)currPt;

        Vector3 a = pts[currPt];
        Vector3 b = pts[currPt + 1];
        Vector3 c = pts[currPt + 2];
        Vector3 d = pts[currPt + 3];

        return 1.5f * (-a + 3f * b - 3f * c + d) * (u * u)
                + (2f * a - 5f * b + 4f * c - d) * u
                + .5f * c - .5f * a;
    }


    public void GizmoDraw(float t)
    {
        Gizmos.color = Color.white;
        Vector3 prevPt = Interp(0);

        for (int i = 1; i <= 20; i++)
        {
            float pm = (float)i / 20f;
            Vector3 currPt = Interp(pm);

            prevPt = currPt;
        }

        Gizmos.color = Color.blue;
        Vector3 pos = Interp(t);

    }
}