using UnityEngine;

/// <summary>
/// Mouse pointer drag to translate gameobject.
/// </summary>
public class MouseTranslate : MonoBehaviour
{
    #region Field and Property
    /// <summary>
    /// Target camera for translate direction.
    /// </summary>
    public Transform targetCamera;

    /// <summary>
    /// Settings of mouse button and pointer.
    /// </summary>
    public MouseSettings mouseSettings = new MouseSettings(0, 1, 0);

    /// <summary>
    /// Settings of move area.
    /// </summary>
    public PlaneArea areaSettings = new PlaneArea(null, 10, 10);

    /// <summary>
    /// Damper for move.
    /// </summary>
    [Range(0, 10)]
    public float damper = 5;

    /// <summary>
    /// Current offset base area center.
    /// </summary>
    public Vector3 CurrentOffset;

    /// <summary>
    /// Target offset base area center.
    /// </summary>
    public Vector3 targetOffset;

    public AroundCamera mAroundCamera;
    #endregion

    #region Protected Method
    protected virtual void Start()
    {
        Initialize();
        mAroundCamera = Component.FindObjectOfType<AroundCamera>();
    }
    public float mCameraDistance = 0.0f;

    protected virtual void Update()
    {
        if (AroundCamera.IsTouchedUI()) return;

        Ray ray = new Ray(Camera.main.transform.position, Camera.main.transform.forward);
        RaycastHit hit;
        if (Physics.Raycast(ray, out hit, float.MaxValue))
        {
            float cameraDistance = Vector3.Distance(Camera.main.transform.position, hit.point);
            mouseSettings.pointerSensitivity = cameraDistance / 10;
            mCameraDistance = cameraDistance;
        }
        TranslateByMouse();
    }

    /// <summary>
    /// Initialize component.
    /// </summary>
    protected virtual void Initialize()
    {
        CurrentOffset = targetOffset = transform.position - areaSettings.center.position;
    }

    /// <summary>
    /// Translate this gameobject by mouse.
    /// </summary>
    public void TranslateByMouse()
    {
        Vector3 preOffset = targetOffset;
        float mouseX = 0;
        float mouseY = 0;
#if !UNITY_ANDROID
        if (Input.GetMouseButton(mouseSettings.mouseButtonID))
        {
            //Mouse pointer.
            mouseX = Input.GetAxis("Mouse X") * mouseSettings.pointerSensitivity;
            mouseY = Input.GetAxis("Mouse Y") * mouseSettings.pointerSensitivity;
        }
#else

        if (Input.touchCount == 1)
        {
            Touch touch0 = Input.GetTouch(0);
            if (touch0.phase == TouchPhase.Moved)
            {
                //Mouse pointer.
                mouseX = Input.GetAxis("Mouse X") * mouseSettings.pointerSensitivity * 0.2f;
                mouseY = Input.GetAxis("Mouse Y") * mouseSettings.pointerSensitivity * 0.2f;
            }
        }
#endif
        //Deal with offset base direction of target camera.
        targetOffset -= targetCamera.right * mouseX;
        targetOffset -= Vector3.Cross(targetCamera.right, Vector3.up) * mouseY;

        //Range limit.
        targetOffset.x = Mathf.Clamp(targetOffset.x, -areaSettings.width, areaSettings.width);
        targetOffset.z = Mathf.Clamp(targetOffset.z, -areaSettings.length, areaSettings.length);
        if (!MovableDetection())
        {
            targetOffset = preOffset;
            return;
        }

        //Lerp and update transform position.
        CurrentOffset = Vector3.Lerp(CurrentOffset, targetOffset, damper * Time.deltaTime);

        //Not Lerp
        //CurrentOffset = targetOffset;
        transform.position = areaSettings.center.position + CurrentOffset;

#if !UNITY_ANDROID
        if (Vector3.Distance(CurrentOffset, targetOffset) > 1.0f)
            PlayerPrefs.SetInt("CameraTranslating", 1);
        else
            PlayerPrefs.SetInt("CameraTranslating", 0);
#endif
    }

    bool MovableDetection()
    {
        if (!mAroundCamera.mIsMovableDetection) return true;

        Vector3 prePos = transform.position;
        transform.position = areaSettings.center.position + targetOffset;
        Vector3 curPos = transform.position - mAroundCamera.transform.forward * mAroundCamera.targetDistance;
        if (Physics.Linecast(mAroundCamera.transform.position, curPos))
        {
            transform.position = prePos;
            return false;
        }

        return true;
    }

#endregion
}