using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Runtime.InteropServices;
using System;
using AOT;

#if UNITY_IOS
using UnityEngine.iOS;
#endif

namespace MoreMountains.NiceVibrations
{
    /// <summary>
    /// This class handles all iOS haptics specific calls for devices that support the CoreHaptics API (post iOS 13)
    /// </summary>
	public static class MMNViOSCoreHaptics
    {
        public static event Action OnHapticPatternStopped;
        public static event Action OnHapticPatternError;
        public static event Action OnHapticPatternReset;

        private static float _initialContinuousIntensity;
        private static float _initialContinuousSharpness;

#if UNITY_IOS && !UNITY_EDITOR
        [DllImport("__Internal")]
        private static extern bool MMNViOS_CoreHapticsSupported();
        [DllImport("__Internal")]
        private static extern void MMNViOS_CreateEngine();
        [DllImport("__Internal")]
        private static extern void MMNViOS_StopEngine();
        [DllImport("__Internal")]
        private static extern void MMNViOS_PlayTransientHapticPattern(float intensity, float sharpness, bool threaded);
        [DllImport("__Internal")]
        private static extern void MMNViOS_PlayContinuousHapticPattern(float intensity, float sharpness, float duration, bool threaded);
        [DllImport("__Internal")]
        private static extern void MMNViOS_UpdateContinuousHapticPattern(float intensity, float sharpness, bool threaded);
        [DllImport("__Internal")]
        private static extern void MMNViOS_StopContinuousHaptic();
        [DllImport("__Internal")]
        private static extern void MMNViOS_PlayCoreHapticsFromJSON(string jsonString, bool threaded);
        [DllImport("__Internal")]
        private static extern void MMNViOS_CoreHapticsRegisterHapticEngineFinishedCallback(Action callback);
        [DllImport("__Internal")]
        private static extern void MMNViOS_CoreHapticsRegisterHapticEngineErrorCallback(Action callback);
        [DllImport("__Internal")]
        private static extern void MMNViOS_CoreHapticsRegisterHapticEngineResetCallback(Action callback);
        [DllImport("__Internal")]
        private static extern void MMNViOS_CoreHapticsSetDebugMode(bool status);
#else
        private static bool MMNViOS_CoreHapticsSupported() { return false; }
        private static void MMNViOS_CoreHapticsSetDebugMode(bool status) { }
        private static void MMNViOS_CreateEngine() { }
        private static void MMNViOS_StopEngine() { }
        private static void MMNViOS_PlayTransientHapticPattern(float intensity, float sharpness, bool threaded) { }
        private static void MMNViOS_PlayContinuousHapticPattern(float intensity, float sharpness, float duration, bool threaded) { }
        private static void MMNViOS_UpdateContinuousHapticPattern(float intensity, float sharpness, bool threaded) { }
        private static void MMNViOS_StopContinuousHaptic() { }
        private static void MMNViOS_PlayCoreHapticsFromJSON(string jsonString, bool threaded) { }
        private static void MMNViOS_CoreHapticsRegisterHapticEngineFinishedCallback(Action callback) { }
        private static void MMNViOS_CoreHapticsRegisterHapticEngineErrorCallback(Action callback) { }
        private static void MMNViOS_CoreHapticsRegisterHapticEngineResetCallback(Action callback) { }
#endif

        /// <summary>
        /// On construction we initialize our haptic engine
        /// </summary>
        static MMNViOSCoreHaptics()
        {
            MMNViOS_CoreHapticsRegisterHapticEngineFinishedCallback(HapticStoppedCallback);
            MMNViOS_CoreHapticsRegisterHapticEngineErrorCallback(HapticsErrorCallback);
            MMNViOS_CoreHapticsRegisterHapticEngineResetCallback(HapticsResetCallback);
        }

        /// <summary>
        /// Plays a core haptics pattern from a JSON string that matches the AHAP format
        /// </summary>
        /// <param name="jsonString"></param>
        public static void PlayCoreHapticsFromJSON(string jsonString, bool threaded = false)
        {
            MMNViOS_PlayCoreHapticsFromJSON(jsonString, threaded);
        }

        /// <summary>
        /// Plays a transient haptic pattern of the specified intensity and sharpness.
        /// Transient haptics are very short haptic patterns.
        /// </summary>
        /// <param name="intensity"></param>
        /// <param name="sharpness"></param>
        public static void PlayTransientHapticPattern(float intensity, float sharpness, bool threaded = false)
        {
            MMNViOS_PlayTransientHapticPattern(intensity, sharpness, threaded);
        }

        /// <summary>
        /// Plays a continuous haptic at the specified intensity and sharpness for the specified duration
        /// The coroutineMonobehaviour parameter is optional, only send that if you intend to raise this specific continuous pattern's intensity higher than its
        /// initial value
        /// </summary>
        /// <param name="intensity"></param>
        /// <param name="sharpness"></param>
        /// <param name="duration"></param>
        /// <param name="coroutineMonobehaviour"></param>
        public static void PlayContinuousHapticPattern(float intensity, float sharpness,
            float duration, MonoBehaviour coroutineMonobehaviour = null, bool threaded = false)
        {
            if (intensity < 0.01f)
            {
                intensity = 0.01f;
            }

            _initialContinuousIntensity = intensity;
            _initialContinuousSharpness = sharpness;

            if (coroutineMonobehaviour != null)
            {
                _initialContinuousIntensity = 1f;
                MMNViOS_PlayContinuousHapticPattern(1f, sharpness, duration, threaded);
                coroutineMonobehaviour.StartCoroutine(ContinuousHapticPatternCoroutine(intensity, sharpness, threaded));
            }
            else
            {
                MMNViOS_PlayContinuousHapticPattern(intensity, sharpness, duration, threaded);
            }
        }

        /// <summary>
        /// This coroutine waits for a frame and returns intensity to its normal value
        /// </summary>
        /// <param name="intensity"></param>
        /// <param name="sharpness"></param>
        /// <returns></returns>
        public static IEnumerator ContinuousHapticPatternCoroutine(float intensity, float sharpness, bool threaded = false)
        {
            yield return null;
            MMNViOS_UpdateContinuousHapticPattern(intensity, sharpness, threaded);
        }

        /// <summary>
        /// This method lets you update the intensity and sharpness of a continuous haptics as it's playing.
        /// Note that this one is a direct implementation of Apple's native method that serves that same purpose, and
        /// the way it works can be confusing, as instead of just setting the value, it multiplies and adds like so :
        /// Sending a dynamic parameter for intensity multiplies the original pattern’s event intensity by the dynamic parameter value.
        /// Sending a dynamic parameter for sharpness adds the dynamic parameter value to the original pattern’s event sharpness.
        /// If you'd rather not have to do weird maths to just set two values, you can use
        /// the UpdateContinuousHapticPatternRational method, which will handle that for you.
        /// </summary>
        /// <param name="intensity"></param>
        /// <param name="sharpness"></param>
        public static void UpdateContinuousHapticPattern(float intensity, float sharpness, bool threaded = false)
        {
            MMNViOS_UpdateContinuousHapticPattern(intensity, sharpness, threaded);
        }

        /// <summary>
        /// This method lets you update the intensity and sharpness of a continuous haptics as it's playing.
        /// It simply sets the intensity and sharpness values to the ones set in parameters
        /// Just note that due to limitations in Apple's implementation, the intensity can't go higher than its initial value.
        /// The only way to bypass that is to pass a monobehaviour to PlayContinuousHapticPattern when calling it
        /// </summary>
        /// <param name="intensity"></param>
        /// <param name="sharpness"></param>
        public static void UpdateContinuousHapticPatternRational(float intensity, float sharpness, bool threaded = false)
        {
            if (_initialContinuousIntensity < 0.01f)
            {
                _initialContinuousIntensity = 0.01f;
            }

            float newIntensity = intensity / _initialContinuousIntensity;
            float newSharpness = sharpness - _initialContinuousSharpness;

            MMNViOS_UpdateContinuousHapticPattern(newIntensity, newSharpness, threaded);
        }

        /// <summary>
        /// Stops all running or continuous haptic patterns
        /// </summary>
        public static void StopHapticPatterns()
        {
            MMNViOS_StopContinuousHaptic();
        }

        /// <summary>
        /// Stops the haptic engine entirely, cutting short any AHAP or transient that may have been playing
        /// </summary>
        public static void CreateEngine()
        {
            MMNViOS_CreateEngine();
        }

        /// <summary>
        /// Stops the haptic engine entirely, cutting short any AHAP or transient that may have been playing
        /// </summary>
        public static void StopEngine()
		{
			MMNViOS_StopEngine();
		}

        /// <summary>
        /// Sets the debug mode to true or false.
        /// While debug mode is active, pretty much every haptic call will output a log in the console.
        /// Useful when debugging without a device
        /// </summary>
        /// <param name="newStatus"></param>
        public static void SetDebugMode(bool newStatus)
        {
            MMNViOS_CoreHapticsSetDebugMode(newStatus);
        }

        /// <summary>
        /// Returns true if CoreHaptics are supported, false otherwise
        /// </summary>
        /// <returns></returns>
        public static bool CoreHapticsSupported()
        {
            return MMNViOS_CoreHapticsSupported();
        }


        /// <summary>
        /// Triggers the haptics stopped callback
        /// </summary>
        #if UNITY_IOS
        [MonoPInvokeCallback(typeof(Action))]
        #endif
        private static void HapticStoppedCallback()
        {
            OnHapticPatternStopped?.Invoke();
        }

        /// <summary>
        /// Triggers the haptics error callback
        /// </summary>
        #if UNITY_IOS
        [MonoPInvokeCallback(typeof(Action))]
        #endif
        private static void HapticsErrorCallback()
        {
            OnHapticPatternError?.Invoke();
        }

        /// <summary>
        /// Triggers the haptics reset callback
        /// </summary>
        #if UNITY_IOS
        [MonoPInvokeCallback(typeof(Action))]
        #endif
        private static void HapticsResetCallback()
        {
            OnHapticPatternReset?.Invoke();
        }
    }
}