using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Firebase;
using Firebase.Analytics;
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
{
    /// <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;
        private FirebaseApp _firebaseApp;
        private Task _initializationTask;

        public bool IsReady { get; private set; }

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

            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}");
            }
        }

        public void TrackAppFirstOpen()
        {
            if (!IsReady || _config == null || !_config.enableFirebaseAnalytics)
                return;

            FirebaseAnalytics.LogEvent(FirebaseAnalytics.EventTutorialComplete,
                new Parameter("device_model", SystemInfo.deviceModel),
                new Parameter("os_version", SystemInfo.operatingSystem));

            Debug.Log("[FirebaseService] 📲 App 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;
            }

            if (!_config.enableFirebaseAnalytics && !_config.enableFirebaseRemoteConfig)
            {
                Debug.Log("[FirebaseService] Firebase disabled in SDKConfig.");
                return;
            }

            if (_initializationTask != null)
            {
                await _initializationTask; // Wait for ongoing init
                return;
            }

            _initializationTask = InitializeFirebaseAsync();
            await _initializationTask;
        }

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

        private async Task InitializeFirebaseAsync()
        {
            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.");

                // ✅ Yeni sistemde EventService interface üzerinden invoke
                _eventService?.Invoke(new ShiroginEvents.Firebase.FirebaseReadyEvent());
            }
            catch (Exception ex)
            {
                Debug.LogError($"[FirebaseService] ❌ Firebase initialization failed: {ex.Message}");
            }
        }
    }
}