using System;
using System.Threading;
using RebootKit.Engine.Foundation;
using UnityEngine;

namespace RebootKit.Engine.Services.Game {
    public abstract class GameModeAsset : FactoryAsset<GameMode> {
        [field: SerializeField]
        public GameMode.Config GameModeConfig { get; private set; }

        public override GameMode Create(DIContext context) {
            GameMode gameMode = new(GameModeConfig);
            context.Inject(gameMode);
            ConfigureGameMode(gameMode);
            return gameMode;
        }

        public abstract void ConfigureGameMode(GameMode gameMode);
    }
    
    public class GameMode : IDisposable {
        [Serializable]
        public class Config {
            public ControllerAsset[] controllers;
        }
        
        readonly Config m_Config;
        readonly ControllersManager<IController> m_Controllers;

        readonly CancellationTokenSource m_DestroyCancellationTokenSource;

        [Inject] DIContext m_DIContext;
        bool m_IsRunning;

        public GameMode(Config config) {
            m_Config = config;
            m_IsRunning = false;

            m_DestroyCancellationTokenSource = new CancellationTokenSource();
            m_Controllers = new ControllersManager<IController>(m_DestroyCancellationTokenSource.Token);
        }

        public void Dispose() {
            m_DestroyCancellationTokenSource.Cancel();
            m_Controllers.Dispose();
        }

        public async Awaitable<bool> Start(CancellationToken cancellationToken) {
            m_Controllers.Add(m_Config.controllers, m_DIContext);
            await m_Controllers.Start(cancellationToken);

            m_IsRunning = true;
            return true;
        }

        public void Stop() {
            m_IsRunning = false;

            m_Controllers.Stop();
        }

        public void Tick() {
            m_Controllers.Tick();
        }

        public void AddController(IController controller) {
            m_Controllers.Add(controller);
        }

        public T FindController<T>() where T : class, IController {
            if (m_Controllers.TryFind<T>(out T controller)) {
                return controller;
            }
            
            return null;
        }
    }
}