using System;
using System.Collections.Generic;
using System.Threading.Tasks;
#if SHIROGIN_FIREBASE_ANALYTICS || SHIROGIN_FIREBASE_REMOTE_CONFIG
using Firebase;
using Firebase.Analytics;
#endif
using ShiroginSDK.Runtime.Core.SDK;
using ShiroginSDK.Runtime.Modules.Events;
using ShiroginSDK.Runtime.Services.Base;
using ShiroginSDK.Runtime.Services.Interfaces;
using UnityEngine;

namespace ShiroginSDK.Runtime.Services.Implementations.Firebase
{
#if SHIROGIN_FIREBASE_ANALYTICS || SHIROGIN_FIREBASE_REMOTE_CONFIG
    /// <summary>
    ///     Centralized Firebase handler for ShiroginSDK.
    ///     Handles initialization, readiness and event logging for analytics or remote config.
    /// </summary>
    public class FirebaseService : ServiceBase, IFirebaseService
    {
        private FirebaseApp _firebaseApp;
        private Task _initializationTask;
        private ShiroginConfig _config;

        private IEventService _eventService;

        public bool IsReady { get; private set; }

        // ----------------------------------------------------------
        // Analytics
        // ----------------------------------------------------------
        public void LogEvent(string eventName, Dictionary<string, object> parameters = null)
        {
#if SHIROGIN_FIREBASE_ANALYTICS
            try
            {
                if (parameters == null)
                {
                    FirebaseAnalytics.LogEvent(eventName);
                }
                else
                {
                    var paramList = new List<Parameter>();
                    foreach (var kvp in parameters)
                        switch (kvp.Value)
                        {
                            case string s:
                                paramList.Add(new Parameter(kvp.Key, s));
                                break;
                            case int i:
                                paramList.Add(new Parameter(kvp.Key, i));
                                break;
                            case double d:
                                paramList.Add(new Parameter(kvp.Key, d));
                                break;
                            case float f:
                                paramList.Add(new Parameter(kvp.Key, f));
                                break;
                            default:
                                paramList.Add(new Parameter(kvp.Key, kvp.Value?.ToString() ?? "null"));
                                break;
                        }

                    FirebaseAnalytics.LogEvent(eventName, paramList.ToArray());
                }

                Debug.Log($"[FirebaseService] ✅ Event logged: {eventName}");
            }
            catch (Exception ex)
            {
                Debug.LogError($"[FirebaseService] ❌ Failed to log event {eventName}: {ex.Message}");
            }
#else
            Debug.LogWarning($"[FirebaseService] ⚠️ Not ready or disabled. Skipped event: {eventName}");
#endif
        }

        public void TrackAppFirstOpen()
        {
            if (!IsReady || _config == null)
                return;
#if SHIROGIN_FIREBASE_ANALYTICS
            FirebaseAnalytics.LogEvent(FirebaseAnalytics.EventTutorialComplete,
                new Parameter("device_model", SystemInfo.deviceModel),
                new Parameter("os_version", SystemInfo.operatingSystem));
                        Debug.Log("[FirebaseService] 📲 App first open tracked.");
#else
            Debug.Log("[FirebaseService] Dummy first open tracked.");
#endif
        }

        // ----------------------------------------------------------
        // Initialization
        // ----------------------------------------------------------
        protected override async void OnInitialize()
        {
            _config = ShiroginConfig.Load();
            _eventService = ServiceLocator.Get<IEventService>();

            if (!_config.enableFirebaseAnalytics && !_config.enableFirebaseRemoteConfig)
            {
                Debug.LogWarning(
                    "[FirebaseService] 🛑 All Firebase modules DISABLED in Config. Running in Dummy Mode.");
                return;
            }

            if (_config == null)
            {
                Debug.LogError("[FirebaseService] Missing SDKConfig.");
                return;
            }
#if SHIROGIN_FIREBASE_ANALYTICS || SHIROGIN_FIREBASE_REMOTE_CONFIG
            if (_initializationTask != null)
            {
                await _initializationTask; // Wait for ongoing init
                return;
            }

            _initializationTask = InitializeFirebaseAsync();
            await _initializationTask;
#else
            Debug.Log(
                "[FirebaseService] ⚠️ Firebase SDK not installed or 'SHIROGIN_FIREBASE_ANALYTICS' 'SHIROGIN_FIREBASE_REMOTE_CONFIG' not defined. Running in Headless Mode.");
#endif
        }

        protected override void OnDispose()
        {
#if SHIROGIN_FIREBASE_ANALYTICS || SHIROGIN_FIREBASE_REMOTE_CONFIG
            _firebaseApp = null;
#endif
            IsReady = false;
            _eventService = null;
        }

        private async Task InitializeFirebaseAsync()
        {
#if SHIROGIN_FIREBASE_ANALYTICS || SHIROGIN_FIREBASE_REMOTE_CONFIG
try
            {
                var dep = await FirebaseApp.CheckAndFixDependenciesAsync();
                if (dep != DependencyStatus.Available)
                {
                    Debug.LogError($"[FirebaseService] ❌ Dependency error: {dep}");
                    return;
                }

                _firebaseApp = FirebaseApp.DefaultInstance;
                IsReady = true;

                Debug.Log("[FirebaseService] ✅ Firebase initialized successfully.");

                _eventService?.Invoke(new ShiroginEvents.Firebase.FirebaseReadyEvent());
            }
            catch (Exception ex)
            {
                Debug.LogError($"[FirebaseService] ❌ Firebase initialization failed: {ex.Message}");
            }
#else
            Debug.Log(
                "[FirebaseService] ⚠️ Firebase SDK not installed or 'SHIROGIN_FIREBASE_ANALYTICS' 'SHIROGIN_FIREBASE_REMOTE_CONFIG' not defined. Running in Headless Mode.");

#endif
        }
    }
#else
    /// <summary>
    ///     Centralized Firebase handler for ShiroginSDK.
    ///     Handles initialization, readiness and event logging for analytics or remote config.
    /// </summary>
    public class FirebaseService : ServiceBase, IFirebaseService
    {
        private ShiroginConfig _config;

        private IEventService _eventService;

        public bool IsReady { get; private set; }

        // ----------------------------------------------------------
        // Analytics
        // ----------------------------------------------------------
        public void LogEvent(string eventName, Dictionary<string, object> parameters = null)
        {
            Debug.LogWarning($"[FirebaseService] ⚠️ Not ready or disabled. Skipped event: {eventName}");
        }

        public void TrackAppFirstOpen()
        {
            if (!IsReady || _config == null)
                return;
            Debug.Log("[FirebaseService] Dummy first open tracked.");
        }

        // ----------------------------------------------------------
        // Initialization
        // ----------------------------------------------------------
        protected override async void OnInitialize()
        {
            _config = ShiroginConfig.Load();
            _eventService = ServiceLocator.Get<IEventService>();

            if (_config == null)
            {
                Debug.LogError("[FirebaseService] Missing SDKConfig.");
                return;
            }

            Debug.Log(
                "[FirebaseService] ⚠Dummy OnInitialize");
        }

        protected override void OnDispose()
        {
            IsReady = false;
            _eventService = null;
        }

        private async Task InitializeFirebaseAsync()
        {
            Debug.Log(
                "[FirebaseService] ⚠Dummy InitializeFirebaseAsync");
        }
    }
#endif
}