using UnityEngine;
using TeamUtility.IO;

using BnG.TrackData;
using System.Collections;

public class ShipCamera : ShipBase {

    // CAMERA SETTINGS
    public Vector3 cOffset = new Vector3(0.0f, 0.15f, -1f);
    public float cFoV = 75.0f;
    public float tcSpeed = 13.0f;
    public float sensitivity = 0.15f;

    private float tcDirectionLag;
    private float tcDirectionLag2;
    private float tcDirectionLag3;
    private Vector3 tcActualOffset;
    private float tcPitchOffset;
    private float tcPitchHeight;
    private float tcVelocityHeight;
    private float tcInputOffset;

    private Vector3 tcTrackOffset;
    private Vector3 tcFinalOffset;
    private Vector2 trackHeightOffset;
    private float trackHeightYSign;
    private float wantedHeight;
    private float tcSideZ;
    private float tcSteerOffset;

    private float tcSectionLerp;
    private Vector3 tcSectionOffset;
    private float tcFallOffset;

    private float tcX;
    private float tcY;
    private float tcZ;

    public int cameraMode;
    private bool lookingBehind;

    // FALL LAG
    private float tcFallTimer;
    private float tcFallTimerGain;
    private float tcFallLagY;
    private float tcFallLagZ;

    // cockpit offsets
    private Vector3 cockpitOffset;
    private Vector3 cockpitRotation;

    private GameObject cameraHelper;

    void Start()
    {
        // Create new transform helper
        cameraHelper = new GameObject("_TRACKHELPER");
    }

    void Update()
    {
        // do nothing if the game is paused
        if (GameSettings.isPaused)
            return;

        // Cycle camera mode
        if (cInput.GetButtonDown("Camera"))
            cameraMode++;

        if (cameraMode > 2)
        {
            transform.parent = r.transform;
            cameraMode = 0;
        }

        // Look Behind Checks
        if (cInput.GetButtonDown("Look Behind"))
        {
            r.mesh.GetComponent<MeshRenderer>().enabled = true;
            lookingBehind = true;
        }

        if (cInput.GetButtonUp("Look Behind"))
        {
            if (cameraMode == 0)
                r.mesh.GetComponent<MeshRenderer>().enabled = false;
            lookingBehind = false;
        }
    }

    void FixedUpdate()
    {
        if (r.isRespawning && cameraMode == 0)
        {
            ReverseChase();
        }
        else
        {
            if (lookingBehind)
            {
                ReverseChase();
            }
            else
            {
                switch (cameraMode)
                {
                    case 0:
                        // Enable ship mesh
                        r.mesh.GetComponent<MeshRenderer>().enabled = true;
                        r.cam.nearClipPlane = 0.05f;
                        FollowTrack();
                        break;
                    case 1:
                        // Disable ship mesh
                        r.mesh.GetComponent<MeshRenderer>().enabled = false;
                        r.cam.nearClipPlane = 0.05f;
                        InternalCamera();
                        break;
                    case 2:
                        // Disable ship mesh
                        r.mesh.GetComponent<MeshRenderer>().enabled = false;
                        r.cam.nearClipPlane = 0.01f;
                        CockpitCam();
                        break;

                }
            }
        }
    }

    private void CockpitCam()
    {
        transform.parent = r.settings.transform;


        cockpitOffset.x = Mathf.Lerp(cockpitOffset.x, (r.sim.turnAmount / r.settings.TURN_SPEED) * 0.035f, Time.deltaTime * r.settings.CAMERA_OFFSET_SPEED.x);
        cockpitOffset.y = 0.008f;
        cockpitRotation.x = Mathf.Lerp(cockpitRotation.x, r.input.AXIS_PITCH * 5, Time.deltaTime * (r.settings.CAMERA_OFFSET_SPEED.x * 0.1f));
        cockpitRotation.y = Mathf.Lerp(cockpitRotation.y, (r.sim.turnAmount / r.settings.TURN_SPEED) * 10, Time.deltaTime * r.settings.CAMERA_OFFSET_SPEED.x);
        transform.localPosition = r.settings.REF_COCKPITMESH.transform.localPosition + cockpitOffset;
        transform.localRotation = Quaternion.Euler(cockpitRotation.x, cockpitRotation.y, 0.0f);
    }

    private void ReverseChase()
    {
        // parent camera
        transform.parent = r.transform;

        // offset camera
        tcSteerOffset = Mathf.Lerp(tcSteerOffset, -r.input.AXIS_STEER * 0.03f, Time.deltaTime * (r.settings.CAMERA_OFFSET_SPEED.x * 0.32f));
        transform.localPosition = new Vector3(tcSteerOffset, cOffset.y, -cOffset.z * 0.6f);
        transform.localRotation = Quaternion.Euler(0.0f, 180.0f, 0.0f);

        // update FoV
        r.cam.fieldOfView = 75.0f;
    }

    private void FollowTrack()
    {
        // parent camera
        transform.parent = r.transform;

        // only follow track if current section exist
        if (r.currentSection == null)
            return;

        // position and rotate track helper (this is so we have a transform to work with)
        cameraHelper.transform.position = r.currentSection.position;
        cameraHelper.transform.rotation = TrackHelpers.SectionGetRotation(r.currentSection);

        // figure out the camera's offset to the track
        Vector3 cameraOffset = cameraHelper.transform.InverseTransformPoint(transform.position);

        // figure out which way the ship is facing and interpolate track direction dot product value to it
        Vector3 trackForward = cameraHelper.transform.forward;
        tcDirectionLag = Mathf.Lerp(tcDirectionLag, Vector3.Dot(transform.forward, trackForward), Time.deltaTime * (tcSpeed * 0.5f));
        tcDirectionLag2 = Mathf.Lerp(tcDirectionLag2, Vector3.Dot(transform.forward, TrackHelpers.SectionGetRotation(r.currentSection) * Vector3.right), Time.deltaTime * (tcSpeed * 0.5f));
        tcDirectionLag3 = Mathf.Lerp(tcDirectionLag3, Vector3.Dot(transform.right, TrackHelpers.SectionGetRotation(r.currentSection) * Vector3.right), Time.deltaTime * (tcSpeed * 0.5f));

        tcTrackOffset = Vector3.Lerp(tcTrackOffset, cameraOffset * tcDirectionLag, Time.deltaTime * 25);
        tcFinalOffset = Vector3.Lerp(tcFinalOffset, cameraOffset, Time.deltaTime * 25);

        // interpolate positions
        tcSteerOffset = Mathf.Lerp(tcSteerOffset, r.input.AXIS_STEER * 0.03f, Time.deltaTime * (r.settings.CAMERA_OFFSET_SPEED.x * 0.32f));
        tcX = Mathf.Lerp(tcX, -tcTrackOffset.x * r.settings.CAMERA_OFFSET_SENSITIVITY.x, Time.deltaTime * r.settings.CAMERA_OFFSET_SPEED.x);
        tcY = Mathf.Lerp(tcY, (Mathf.Abs(tcFinalOffset.x)) * r.settings.CAMERA_OFFSET_SENSITIVITY.y, Time.deltaTime * r.settings.CAMERA_OFFSET_SPEED.y);
        tcZ = Mathf.Lerp(tcZ, (tcFinalOffset.x * r.settings.CAMERA_OFFSET_SENSITIVITY.z) * -tcDirectionLag2, Time.deltaTime * r.settings.CAMERA_OFFSET_SPEED.z);
        tcSideZ = Mathf.Lerp(tcSideZ, ((-Mathf.Abs(-tcTrackOffset.x * -tcTrackOffset.x) * 0.8f) * r.settings.CAMERA_OFFSET_ZMULT) * tcDirectionLag3, Time.deltaTime * r.settings.CAMREA_OFFSET_ZMULT_SPEED);

        // increase/decrease distance to ship on slopes
        float upDir = Vector3.Dot(Vector3.up, r.transform.forward);
        float dirNorm = Mathf.Abs(upDir) / 1.0f;
        float trackDir = Vector3.Dot(TrackHelpers.SectionGetRotation(r.currentSection) * Vector3.up, r.transform.forward);
        tcPitchOffset = Mathf.Lerp(tcPitchOffset, (-upDir * r.settings.CAMERA_OFFSET_TRACK.z * 0.2f) * dirNorm, Time.deltaTime * tcSpeed);
        tcPitchHeight = Mathf.Lerp(tcPitchHeight, (-Mathf.Abs(upDir * r.settings.CAMERA_OFFSET_TRACK.y)), Time.deltaTime * (tcSpeed * 0.2f));

        // fall Offsets
        if (r.sim.isShipGrounded || !r.jumpHeight)
        {
            tcFallTimer = 0;
            tcFallTimerGain = 0;
        }
        else
        {
            tcFallTimer += Time.deltaTime;
        }

        if (tcFallTimer > 0.0f)
        {
            tcFallTimerGain = Mathf.Lerp(tcFallTimerGain, 0.8f, Time.deltaTime);
            tcFallLagY = Mathf.Lerp(tcFallLagY, 0.0f, Time.deltaTime * tcFallTimerGain);
            tcFallLagZ = Mathf.Lerp(tcFallLagZ, 0.0f, Time.deltaTime * (tcFallTimerGain * 4));
        }
        else
        {
            tcFallTimerGain = 0;
            tcFallLagY = Mathf.Lerp(tcFallLagY, 0.0f, Time.deltaTime * 4);
            tcFallLagZ = Mathf.Lerp(tcFallLagZ, 0.0f, Time.deltaTime * 4);
        }

        if (r.transform.InverseTransformDirection(r.body.velocity).y > 0)
        {
            tcFallOffset = Mathf.Lerp(tcFallOffset, r.transform.InverseTransformDirection(r.body.velocity).y * 0.008f, Time.deltaTime * (tcSpeed * 0.4f));
        } else
        {
            tcFallOffset = Mathf.Lerp(tcFallOffset, 0.0f, Time.deltaTime * (tcSpeed * 0.3f));
        }

        // distance to track offset
        wantedHeight = Mathf.Lerp(wantedHeight, (transform.position.y - r.currentSection.position.y) - r.settings.AG_HOVER_HEIGHT, Time.deltaTime * (r.settings.CAMERA_FALL_SPEED.y * 10));
        trackHeightYSign = Mathf.Lerp(trackHeightYSign, Mathf.Sign(r.body.velocity.y), Time.deltaTime * (r.settings.CAMERA_FALL_SPEED.y * 2));
        trackHeightOffset.x = Mathf.Lerp(trackHeightOffset.x, -wantedHeight * (r.settings.CAMERA_FALL_SENSITIVITY.z * 0.5f), Time.deltaTime * (r.settings.CAMERA_FALL_SPEED.z));
        trackHeightOffset.y = Mathf.Lerp(trackHeightOffset.y, (wantedHeight * (r.settings.CAMERA_FALL_SENSITIVITY.y * 0.5f)) * trackHeightYSign, Time.deltaTime * (r.settings.CAMERA_FALL_SPEED.y));

        // apply camera offset
        transform.localPosition = new Vector3(r.settings.CAMERA_OFFSET_TRACK.x + tcX + tcSteerOffset,
            r.settings.CAMERA_OFFSET_TRACK.y + tcY + tcFallLagY + tcPitchHeight + tcFallOffset + tcVelocityHeight + (-trackHeightOffset.y * 0.5f),
            r.settings.CAMERA_OFFSET_TRACK.z + tcZ + tcPitchOffset + tcFallLagZ + trackHeightOffset.x + tcSideZ);

        // update Rotation
        transform.rotation = r.transform.rotation;

        // update FoV
        r.cam.fieldOfView = 75.0f;
    }

    private void InternalCamera()
    {
        // parent camera
        transform.parent = r.axis.transform;

        // zero out transform
        transform.localPosition = r.settings.CAMERA_OFFSET_INTERNAL;
        transform.localRotation = Quaternion.identity;

        // update FoV
        r.cam.fieldOfView = 75.0f;
    }

}