#if UNITY_ANALYTICS || UNITY_EDITOR
using System;
using UnityEngine.InputSystem.Layouts;
#if UNITY_EDITOR
using UnityEngine.InputSystem.Editor;
#endif // UNITY_EDITOR

////FIXME: apparently shutdown events are not coming through in the analytics backend

namespace UnityEngine.InputSystem
{
    internal static class InputAnalytics
    {
        public const string kVendorKey = "unity.input";

        // Struct similar to AnalyticInfo for simplifying usage.
        public struct InputAnalyticInfo
        {
            public InputAnalyticInfo(string name, int maxEventsPerHour, int maxNumberOfElements)
            {
                Name = name;
                MaxEventsPerHour = maxEventsPerHour;
                MaxNumberOfElements = maxNumberOfElements;
            }

            public readonly string Name;
            public readonly int MaxEventsPerHour;
            public readonly int MaxNumberOfElements;
        }

        // Note: Needs to be externalized from interface depending on C# version.
        public interface IInputAnalyticData
#if UNITY_EDITOR && UNITY_2023_2_OR_NEWER
            : UnityEngine.Analytics.IAnalytic.IData
#endif
        {}

        // Unity 2023.2+ deprecates legacy interfaces for registering and sending editor analytics and
        // replaces them with attribute annotations and required interface implementations.
        // The IInputAnalytic interface have been introduced here to support both variants
        // of analytics reporting. Notice that a difference is that data is collected lazily as part
        // of sending the analytics via the framework.
        public interface IInputAnalytic
#if UNITY_EDITOR && UNITY_2023_2_OR_NEWER
            : UnityEngine.Analytics.IAnalytic
#endif // UNITY_EDITOR && UNITY_2023_2_OR_NEWER
        {
            InputAnalyticInfo info { get; } // May be removed when only supporting 2023.2+ versions

#if !UNITY_2023_2_OR_NEWER
            // Conditionally mimic UnityEngine.Analytics.IAnalytic
            bool TryGatherData(out IInputAnalyticData data, out Exception error);
#endif // !UNITY_2023_2_OR_NEWER
        }

        public static void Initialize(InputManager manager)
        {
            Debug.Assert(manager.m_Runtime != null);
        }

        public static void OnStartup(InputManager manager)
        {
            manager.m_Runtime.SendAnalytic(new StartupEventAnalytic(manager));
        }

        public static void OnShutdown(InputManager manager)
        {
            manager.m_Runtime.SendAnalytic(new ShutdownEventDataAnalytic(manager));
        }

        /// <summary>
        /// Data about what configuration we start up with.
        /// </summary>
        /// <remarks>
        /// Has data about the devices present at startup so that we can know what's being
        /// used out there. Also has data about devices we couldn't recognize.
        ///
        /// Note that we exclude devices that are always present (e.g. keyboard and mouse
        /// on desktops or touchscreen on phones).
        /// </remarks>
        [Serializable]
        public struct StartupEventData : IInputAnalyticData
        {
            public string version;
            public DeviceInfo[] devices;
            public DeviceInfo[] unrecognized_devices;

            ////REVIEW: ATM we have no way of retrieving these in the player
            #if UNITY_EDITOR
            public bool new_enabled;
            public bool old_enabled;
            #endif

            [Serializable]
            public struct DeviceInfo
            {
                public string layout;
                public string @interface;
                public string product;
                public bool native;

                public static DeviceInfo FromDescription(InputDeviceDescription description, bool native = false, string layout = null)
                {
                    string product;
                    if (!string.IsNullOrEmpty(description.product) && !string.IsNullOrEmpty(description.manufacturer))
                        product = $"{description.manufacturer} {description.product}";
                    else if (!string.IsNullOrEmpty(description.product))
                        product = description.product;
                    else
                        product = description.manufacturer;

                    if (string.IsNullOrEmpty(layout))
                        layout = description.deviceClass;

                    return new DeviceInfo
                    {
                        layout = layout,
                        @interface = description.interfaceName,
                        product = product,
                        native = native
                    };
                }
            }
        }

#if UNITY_EDITOR && UNITY_2023_2_OR_NEWER
        [UnityEngine.Analytics.AnalyticInfo(eventName: kEventName, maxEventsPerHour: kMaxEventsPerHour, maxNumberOfElements: kMaxNumberOfElements, vendorKey: kVendorKey)]
#endif // UNITY_EDITOR && UNITY_2023_2_OR_NEWER
        public struct StartupEventAnalytic : IInputAnalytic
        {
            public const string kEventName = "input_startup";
            public const int kMaxEventsPerHour = 100;
            public const int kMaxNumberOfElements = 100;

            private InputManager m_InputManager;

            public StartupEventAnalytic(InputManager manager)
            {
                m_InputManager = manager;
            }

            public InputAnalyticInfo info => new InputAnalyticInfo(kEventName, kMaxEventsPerHour, kMaxNumberOfElements);

#if UNITY_EDITOR && UNITY_2023_2_OR_NEWER
            public bool TryGatherData(out UnityEngine.Analytics.IAnalytic.IData data, out Exception error)
#else
            public bool TryGatherData(out IInputAnalyticData data, out Exception error)
#endif
            {
                try
                {
                    data = new StartupEventData
                    {
                        version = InputSystem.version.ToString(),
                        devices = CollectRecognizedDevices(m_InputManager),
                        unrecognized_devices = CollectUnrecognizedDevices(m_InputManager),
#if UNITY_EDITOR
                        new_enabled = EditorPlayerSettingHelpers.newSystemBackendsEnabled,
                        old_enabled = EditorPlayerSettingHelpers.oldSystemBackendsEnabled,
#endif // UNITY_EDITOR
                    };
                    error = null;
                    return true;
                }
                catch (Exception e)
                {
                    data = null;
                    error = e;
                    return false;
                }
            }

            private static StartupEventData.DeviceInfo[] CollectRecognizedDevices(InputManager manager)
            {
                var deviceInfo = new StartupEventData.DeviceInfo[manager.devices.Count];
                for (var i = 0; i < manager.devices.Count; ++i)
                {
                    deviceInfo[i] = StartupEventData.DeviceInfo.FromDescription(
                        manager.devices[i].description, manager.devices[i].native, manager.devices[i].layout);
                }
                return deviceInfo;
            }

            private static StartupEventData.DeviceInfo[] CollectUnrecognizedDevices(InputManager manager)
            {
                var n = 0;
                var deviceInfo = new StartupEventData.DeviceInfo[manager.m_AvailableDeviceCount];
                for (var i = 0; i < deviceInfo.Length; ++i)
                {
                    var deviceId = manager.m_AvailableDevices[i].deviceId;
                    if (manager.TryGetDeviceById(deviceId) != null)
                        continue;

                    deviceInfo[n++] = StartupEventData.DeviceInfo.FromDescription(
                        manager.m_AvailableDevices[i].description, manager.m_AvailableDevices[i].isNative);
                }

                if (deviceInfo.Length > n)
                    Array.Resize(ref deviceInfo, n);

                return deviceInfo;
            }
        }

        /// <summary>
        /// Data about when after startup the user first interacted with the application.
        /// </summary>
        [Serializable]
        public struct FirstUserInteractionEventData : IInputAnalyticData
        {
        }

        /// <summary>
        /// Data about what level of data we pumped through the system throughout its lifetime.
        /// </summary>
        [Serializable]
        public struct ShutdownEventData : IInputAnalyticData
        {
            public int max_num_devices;
            public int max_state_size_in_bytes;
            public int total_event_bytes;
            public int total_event_count;
            public int total_frame_count;
            public float total_event_processing_time;
        }

#if (UNITY_EDITOR && UNITY_2023_2_OR_NEWER)
        [UnityEngine.Analytics.AnalyticInfo(eventName: kEventName, maxEventsPerHour: kMaxEventsPerHour,
            maxNumberOfElements: kMaxNumberOfElements, vendorKey: kVendorKey)]
#endif // (UNITY_EDITOR && UNITY_2023_2_OR_NEWER)
        public readonly struct ShutdownEventDataAnalytic : IInputAnalytic
        {
            public const string kEventName = "input_shutdown";
            public const int kMaxEventsPerHour = 100;
            public const int kMaxNumberOfElements = 100;

            private readonly InputManager m_InputManager;

            public ShutdownEventDataAnalytic(InputManager manager)
            {
                m_InputManager = manager;
            }

            public InputAnalyticInfo info => new InputAnalyticInfo(kEventName, kMaxEventsPerHour, kMaxNumberOfElements);

#if UNITY_EDITOR && UNITY_2023_2_OR_NEWER
            public bool TryGatherData(out UnityEngine.Analytics.IAnalytic.IData data, out Exception error)
#else
            public bool TryGatherData(out IInputAnalyticData data, out Exception error)
#endif
            {
                try
                {
                    var metrics = m_InputManager.metrics;
                    data = new ShutdownEventData
                    {
                        max_num_devices = metrics.maxNumDevices,
                        max_state_size_in_bytes = metrics.maxStateSizeInBytes,
                        total_event_bytes = metrics.totalEventBytes,
                        total_event_count = metrics.totalEventCount,
                        total_frame_count = metrics.totalUpdateCount,
                        total_event_processing_time = (float)metrics.totalEventProcessingTime,
                    };
                    error = null;
                    return true;
                }
                catch (Exception e)
                {
                    data = null;
                    error = e;
                    return false;
                }
            }
        }
    }

    internal static class AnalyticExtensions
    {
        internal static void Send<TSource>(this TSource analytic) where TSource : InputAnalytics.IInputAnalytic
        {
            InputSystem.s_Manager?.m_Runtime?.SendAnalytic(analytic);
        }
    }
}

#endif // UNITY_ANALYTICS || UNITY_EDITOR