using System;
using System.Threading;
using System.Threading.Tasks;
using Cysharp.Threading.Tasks;
using Game.Logic;
using Game.Messages;
using Game.Services;
using Game.StateMachines;
using GameLovers.GameData;
using GameLovers.Services;
using GameLovers.Services.Commands;
using GameLovers.Services.Pooling;
using GameLovers.UiService;
using UnityEngine;
using UnityEngine.InputSystem.EnhancedTouch;

namespace Game
{
	/// <summary>
	/// Composes the game and owns the application lifetime.
	/// </summary>
	public class Main : MonoBehaviour
	{
		[SerializeField, Tooltip("Requires a linked Unity Cloud project and granted AnalyticsIntent consent before startup.")]
		private bool _enableAnalytics;

		private readonly CancellationTokenSource _lifetime = new CancellationTokenSource();
		private GameStateMachine _stateMachine;
		private GameServicesLocator _services;
		private IGameLogicLocator _gameLogic;
		private IDataService _dataService;
		private GameUiService _uiService;
		private bool _isPaused;
		private bool _isQuitting;

		/// <summary>Whether the initial game loading flow has completed.</summary>
		public bool IsReady => _stateMachine != null && _stateMachine.IsReady;

		/// <summary>The loading failure preventing the game from continuing, if any.</summary>
		public Exception StartupFailure => _stateMachine?.Failure;

		private void Awake()
		{
			if (MainInstaller.TryResolve<IGameServicesLocator>(out _))
			{
				Destroy(gameObject);
				return;
			}

			var installer = new Installer();

			_uiService = new GameUiService(new AddressablesUiAssetLoader());
			installer.Bind<IMessageBrokerService>(new MessageBrokerService());
			installer.Bind<ITimeService>(new TimeService());
			installer.Bind<GameUiService, IGameUiServiceInit, IGameUiService>(_uiService);
			installer.Bind<IPoolService>(new PoolService());
			installer.Bind<ITickService>(new TickService());
			installer.Bind<ICoroutineService>(new CoroutineService());
			installer.Bind<AssetResolverService, IAssetResolverService, IAssetAdderService>(new AssetResolverService());
			installer.Bind<ConfigsProvider, IConfigsAdder, IConfigsProvider>(new ConfigsProvider());
			installer.Bind<DataService, IDataService, IDataProvider>(new DataService());
			installer.Bind<IAnalyticsService>(new AnalyticsService(installer.Resolve<IMessageBrokerService>(), installer.Resolve<IDataProvider>()));

			var gameLogic = new GameLogicLocator(installer);

			installer.Bind<IGameLogicLocatorInit>(gameLogic);
			installer.Bind<IGameDataProviderLocator>(gameLogic);
			installer.Bind<ICommandService<IGameLogicLocator>>(new CommandService<IGameLogicLocator>(gameLogic, installer.Resolve<IMessageBrokerService>()));

			_services = new GameServicesLocator(installer);
			installer.Bind<IGameServicesLocator>(_services);
			MainInstaller.Bind<IGameDataProviderLocator>(gameLogic);
			MainInstaller.Bind<IGameServicesLocator>(_services);

			_dataService = installer.Resolve<IDataService>();
			_gameLogic = gameLogic;
			_stateMachine = new GameStateMachine(installer, _lifetime.Token);
			Screen.sleepTimeout = SleepTimeout.NeverSleep;
			TaskScheduler.UnobservedTaskException += TaskExceptionLogging;

			DontDestroyOnLoad(gameObject);
		}

		private void Start()
		{
			if (_services != null)
			{
				StartGameAsync().Forget(Debug.LogException);
			}
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			if (!hasFocus)
			{
				SaveData();
			}
		}

		private void OnApplicationPause(bool isPaused)
		{
			if (_services == null || _isQuitting || _isPaused == isPaused)
			{
				return;
			}

			_isPaused = isPaused;

			if (isPaused)
			{
				SaveData();
				_services.AnalyticsService.FlushEvents();
			}

			_services.MessageBrokerService.Publish(new ApplicationPausedMessage { IsPaused = isPaused });
		}

		private void OnApplicationQuit()
		{
			if (_isQuitting || _services == null)
			{
				return;
			}

			_isQuitting = true;
			SaveData();

			try
			{
				_services.MessageBrokerService.Publish(new ApplicationQuitMessage());
			}
			finally
			{
				_services.AnalyticsService.SessionCalls.SessionEnd(_gameLogic.AppLogic.QuitReason);
				_services.AnalyticsService.FlushEvents();
			}
		}

		private void OnDestroy()
		{
			_stateMachine?.Dispose();
			_lifetime.Cancel();
			_lifetime.Dispose();

			if (_services == null)
			{
				return;
			}

			TaskScheduler.UnobservedTaskException -= TaskExceptionLogging;
			_uiService.Dispose();
			_services.Dispose();
			EnhancedTouchSupport.Disable();
			MainInstaller.Clean();
		}

		private async UniTask StartGameAsync()
		{
			try
			{
				EnhancedTouchSupport.Enable();
				await _services.AnalyticsService.InitializeAsync(_enableAnalytics, _lifetime.Token);
				_lifetime.Token.ThrowIfCancellationRequested();
				_stateMachine.Run();
			}
			catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
			{
			}
		}

		private void SaveData()
		{
			try
			{
				_dataService?.SaveAllData();
			}
			catch (Exception exception)
			{
				Debug.LogException(exception);
			}
		}

		private static void TaskExceptionLogging(object sender, UnobservedTaskExceptionEventArgs eventArgs)
		{
			Debug.LogException(eventArgs.Exception);
			eventArgs.SetObserved();
		}
	}
}