/*==============================================================================
Copyright (c) 2010-2014 Qualcomm Connected Experiences, Inc.
All Rights Reserved.
Confidential and Proprietary - Protected under copyright and other laws.
==============================================================================*/

using System.Collections.Generic;
using UnityEngine;

namespace Vuforia
{
    /// <summary>
    /// A custom handler that implements the ITrackableEventHandler interface.
    /// </summary>
    public class TrackableEventHandlerCorrected : MonoBehaviour,
                                                ITrackableEventHandler
    {
        #region PRIVATE_MEMBER_VARIABLES

        private TrackableBehaviour mTrackableBehaviour;
        private Dictionary<Renderer, Vector3> savedScales = new Dictionary<Renderer, Vector3>();
        private Dictionary<Renderer, Vector3> savedLocalPos = new Dictionary<Renderer, Vector3>();
        private Vector3 savedScale;
        private float scalePercentage = 0.14f;

        #endregion // PRIVATE_MEMBER_VARIABLES

        public GameObject targetObject;
        public LayerMask mask;        

        #region UNTIY_MONOBEHAVIOUR_METHODS

        void Start()
        {
            mTrackableBehaviour = GetComponent<TrackableBehaviour>();
            if (mTrackableBehaviour)
            {
                mTrackableBehaviour.RegisterTrackableEventHandler(this);
            }

            // saving local scale for target object (parent of all components)
            savedScale = targetObject.transform.localScale;

            Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
            foreach (Renderer component in rendererComponents)
            {
                // saving local scale for every component
                savedScales[component] = component.transform.localScale;
                // saving local position for every component
                savedLocalPos[component] = component.transform.localPosition;                
            }
        }

        #endregion // UNTIY_MONOBEHAVIOUR_METHODS

        #region PUBLIC_METHODS

        /// <summary>
        /// Implementation of the ITrackableEventHandler function called when the
        /// tracking state changes.
        /// </summary>
        public void OnTrackableStateChanged(
                                        TrackableBehaviour.Status previousStatus,
                                        TrackableBehaviour.Status newStatus)
        {
            if (newStatus == TrackableBehaviour.Status.DETECTED ||
                newStatus == TrackableBehaviour.Status.TRACKED ||
                newStatus == TrackableBehaviour.Status.EXTENDED_TRACKED)
            {
                OnTrackingFound();
            }
            else
            {
                OnTrackingLost();
            }

            if (newStatus == TrackableBehaviour.Status.EXTENDED_TRACKED && targetObject != null)
            {
                Vector3 cameraPos = Camera.main.transform.position;
                Vector3 objectPos = targetObject.transform.position;
                Vector3 direction = targetObject.transform.position - cameraPos;
                RaycastHit hitInfo;
                                
                // trying to hit the spatial mapping surfacing (note the inverted layer mask here)
                if (Physics.Raycast(cameraPos, direction, out hitInfo, Mathf.Infinity, ~mask.value, QueryTriggerInteraction.UseGlobal))
                {
                    Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
                    foreach (Renderer component in rendererComponents)
                    {                            
                        // restore saved local scale and saved local position
                        component.transform.localScale = savedScales[component];
                        component.transform.localPosition = savedLocalPos[component];

                        // setting the local scale according to the new distance
                        component.transform.localScale = component.transform.localScale * scalePercentage;

                        // setting the component to the hit point and correcting for components pivot position (assumed to be in center of component)
                        // Note: changing pivot of component is no option since Vuforia assumes it to be in center                        
                        component.transform.position = hitInfo.point;
                        // correcting constant z-axis offset
                        component.transform.localPosition = component.transform.localPosition + new Vector3(0, 0, 0.03f);
                        // correcting for components pivot position
                        component.transform.localPosition = component.transform.localPosition + savedLocalPos[component] * scalePercentage;
                    }
                }
                else
                {
                    Debug.Log("NO HIT FOR RAYCAST!");
                }
            }
        }

        #endregion // PUBLIC_METHODS

        #region PRIVATE_METHODS


        private void OnTrackingFound()
        {
            Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
            Collider[] colliderComponents = GetComponentsInChildren<Collider>(true);

            // Enable rendering:
            foreach (Renderer component in rendererComponents)
            {
                component.enabled = true;
            }

            // Enable colliders:
            foreach (Collider component in colliderComponents)
            {
                component.enabled = true;
            }

            Debug.Log("Trackable " + mTrackableBehaviour.TrackableName + " found");
        }


        private void OnTrackingLost()
        {
            Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
            Collider[] colliderComponents = GetComponentsInChildren<Collider>(true);

            // Disable rendering:
            foreach (Renderer component in rendererComponents)
            {
                component.enabled = false;
            }

            // Disable colliders:
            foreach (Collider component in colliderComponents)
            {
                component.enabled = false;
            }

            Debug.Log("Trackable " + mTrackableBehaviour.TrackableName + " lost");
        }

        #endregion // PRIVATE_METHODS
    }
}