using System.Threading.Tasks;
using Firebase;
using RocketGM;
using RocketLog;
using UnityEngine;

namespace RocPush
{
    public static class PanPushNotificationController
    {
        public static ILocalNotificationService LocalNotificationService { get; private set; }
        public static IPushNotificationService PushNotificationService { get; private set; }

        private static readonly RocLog _logger = new RocLog(nameof(PanPushNotificationController), DebugLevels.Debug);
        
        private const string UserDeclinedNotificationsKey = "rocketUserDeclinedNotifications";
        
        public static bool IsInitialized { get; private set; }

        public static void Initialize()
        {
            LocalNotificationService = new UnityLocalNotificationService();
            PushNotificationService = new FirebasePushNotificationService();
            
            RocGm.DoAfterInitialized((remoteSettings, gameSettings) =>
            {
                if (!gameSettings.PushEnabled)
                {
                    _logger.Warning(
                        "Push notification initialization is cancelled since it is disabled in remote config.");
                    return;
                }
                
#if ROC_FIREBASE
                _logger.Info("Waiting for Firebase initialization...");
                RocFirebaseController.DoAfterInitialize(InitializeNotificationService);
#else
                InitializeNotificationService();
#endif
            });
        }

        private static async void InitializeNotificationService()
        {
            _logger.Info("Initializing...");
#if !UNITY_EDITOR && (UNITY_ANDROID || UNITY_IOS)
            
            PushNotificationService.TokenReceived += OnPushTokenReceived;
            
            if (!IsUserDeclinedNotifications())
            {
                await RequestNotificationPermissionAsync();
            }
            
            LocalNotificationService.Initialize();
            PushNotificationService.Initialize();
#endif
            IsInitialized = true;
        }

        private static async Task RequestNotificationPermissionAsync()
        {
#if !UNITY_EDITOR && (UNITY_ANDROID || UNITY_IOS)
            
            _logger.Info("Requesting notification permission...");
            
#if UNITY_ANDROID
            var service = new AndroidPermissionService();
#elif UNITY_IOS
            var service = new ApplePermissionService();
#endif

            if (service == null)
            {
                _logger.Error("Unsupported platform");
            }

            var permission = await service.RequestPermissionAsync();

            _logger.Info($"Notification permission result {permission}");
            
            if (permission == PermissionState.Denied)
            {
                SetUserDeclinedNotifications(true);
            }
            
#endif
        }

        private static void OnPushTokenReceived()
        {
#if ROC_GM_REPORTING
            RocGm.Reporting.UpdatePushToken(PushNotificationService.Token);
#endif
        }
        
        private static bool IsUserDeclinedNotifications()
        {
            return PlayerPrefs.GetInt(UserDeclinedNotificationsKey, 0) != 0;
        }
        
        private static void SetUserDeclinedNotifications(bool value)
        {
            PlayerPrefs.SetInt(UserDeclinedNotificationsKey, value ? 1 : 0);
        }
    }
}