using static EgwCoreLib.Lux.Core.Enums;

namespace Lux.API.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProdController : ControllerBase
    {
        #region Public Constructors

        /// <summary>
        /// Costruttore metodo
        /// </summary>
        /// <param name="prodService"></param>
        /// <param name="extMessProc"></param>
        /// <param name="crService"></param>
        public ProdController(IProdService prodService, ExternalMessageProcessor extMessProc, ICalcRuidService crService)
        {
            _prodService = prodService;
            EMProc = extMessProc;
            _calcRuidService = crService;
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Chiamata GET: test status alive
        /// GET: api/Prod/alive
        /// </summary>
        /// <param name="id">uid oggetto</param>
        /// <returns></returns>
        [HttpGet("alive")]
        public async Task<IActionResult> Alive()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            await Task.Delay(1);
            sw.Stop();
            Log.Info($"Alive | {sw.Elapsed.TotalMilliseconds:N3} ms");
            return Ok("OK");
        }

        /// <summary>
        ///  Chiamata GET:
        /// - fornisce il job da eseguire dalla coda (SE presente)
        /// GET: api/Prod/getjob/BEAM/ABC012345
        /// GET: api/Prod/getjob/WINDOW/ABC012345
        /// </summary>
        /// <param name="envir"></param>
        /// <param name="uid"></param>
        /// <returns></returns>
        [HttpGet("getjob/{envir}/{uid}")]
        public async Task<ActionResult<QuestionDTO>> GetJob(string envir, string uid)
        {
            Constants.EXECENVIRONMENTS cEnvir = Constants.EXECENVIRONMENTS.WINDOW;
            Enum.TryParse(envir, out cEnvir);
            var result = await _prodService.GetJobAsync(cEnvir, uid);
            QuestionDTO? deserRes = JsonConvert.DeserializeObject<QuestionDTO>(result);
            if (deserRes != null)
            {
                // verifico RUID code x rigenerarlo...
                if (deserRes.Args != null)
                {
                    // elimino vecchio RUID se esistesse...
                    if (deserRes.Args.ContainsKey("RUID"))
                    {
                        deserRes.Args.Remove("RUID");
                    }
                    // completo info
                    var mode = deserRes.Args["Mode"];
                    var sub = deserRes.Args["SubMode"];
                    string type = string.IsNullOrEmpty(sub) ? mode : $"{mode}-{sub}";
                    // creo registrazione richiesta...
                    var ruid = await _calcRuidService.AddRequestAsync(envir, type, uid);
                    // aggiungo RUID effettivo
                    deserRes.Args.Add("RUID", ruid);
                }
                return Ok(deserRes);
            }
            else
            {
                return NotFound("No Data Found");
            }
        }

        /// <summary>
        /// Chiamata GET:
        /// - fornisce il primo job da eseguire dalla coda (SE presente)
        /// - viene registrato come "in corso" e spostato dalla coda richiesta
        /// GET: api/Prod/getnext/WINDOW
        /// GET: api/Prod/getnext/BEAM
        /// </summary>
        /// <param name="envir">Environment della richiesta</param>
        /// <returns></returns>
        [HttpGet("getnext/{envir}")]
        public async Task<ActionResult<QuestionDTO>> GetNext(string envir)
        {
            Constants.EXECENVIRONMENTS cEnvir = Constants.EXECENVIRONMENTS.WINDOW;
            Enum.TryParse(envir, out cEnvir);
            var result = await _prodService.GetNextAsync(cEnvir);
            QuestionDTO? deserRes = JsonConvert.DeserializeObject<QuestionDTO>(result);
            if (deserRes != null)
            {
                // verifico RUID code x rigenerarlo...
                if (deserRes.Args != null)
                {
                    // elimino vecchio RUID se esistesse...
                    if (deserRes.Args.ContainsKey("RUID"))
                    {
                        deserRes.Args.Remove("RUID");
                    }
                    // completo info
                    var mode = deserRes.Args["Mode"];
                    var sub = deserRes.Args["SubMode"];
                    var uid = deserRes.Args["UID"];
                    string type = string.IsNullOrEmpty(sub) ? mode : $"{mode}-{sub}";

                    // creo registrazione richiesta...
                    var ruid = await _calcRuidService.AddRequestAsync(envir, type, uid);
                    // aggiungo RUID effettivo
                    deserRes.Args.Add("RUID", ruid);
                }
                return Ok(deserRes);
            }
            else
            {
                return NotFound("No Data Available");
            }
        }

        /// <summary>
        /// Ritorno calcolo
        /// </summary>
        /// <param name="retData"></param>
        /// <returns></returns>
        [HttpPost("jobreturn")]
        public async Task<bool> JobReturn([FromBody] AnswerDTO retData)
        {
            bool saved = false;
            // se risposta valida --> processo!
            if (retData != null)
            {
                saved = await EMProc.ProcessAnswer(retData);
                // se in debug forzo save dell'ultima chiamata comunque...
                saved = false;

                // se non avessi salvato e non sapessi cosa fosse --> salvo comunque x debug...
                if (!saved && retData != null)
                {
                    string UID = retData.Args["UID"];
                    var envir = retData.ExecEnvironment;
                    // salvo in area generica...
                    string rawData = JsonConvert.SerializeObject(retData);
                    await EMProc.SaveRawData(UID, retData.ExecEnvironment, rawData);
                }
            }
            // ritorno
            return saved;
        }

        /// <summary>
        /// Chiamata GET: num richieste in coda (se non specificato è waiting, altrimenti )
        /// GET: api/Prod/queue-len/WINDOW/
        /// GET: api/Prod/queue-len/WINDOW/waiting
        /// GET: api/Prod/queue-len/WINDOW/running
        /// GET: api/Prod/queue-len/BEAM/
        /// GET: api/Prod/queue-len/BEAM/waiting
        /// GET: api/Prod/queue-len/BEAM/running
        /// </summary>
        /// <param name="envir">Environment della richiesta</param>
        /// <param name="type">Tipo coda (default waiting)</param>
        /// <returns></returns>
        [HttpGet("qlen/{envir}/{type}")]
        public async Task<IActionResult> QueueLen(string envir, ProdQueueType type = ProdQueueType.waiting)
        {
            Constants.EXECENVIRONMENTS cEnvir = Constants.EXECENVIRONMENTS.WINDOW;
            Enum.TryParse(envir, out cEnvir);
            var result = await _prodService.QueueLenAsync(cEnvir, type);
            return Ok(result);
        }

        /// <summary>
        /// Chiamata GET: dizionario stato richieste
        /// GET: api/Prod/queue-status/
        /// </summary>
        /// <param name="envir">Environment della richiesta</param>
        /// <returns></returns>
        [HttpGet("qstatus/{envir}")]
        public async Task<IActionResult> QueueStatus(string envir)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            Constants.EXECENVIRONMENTS cEnvir = Constants.EXECENVIRONMENTS.WINDOW;
            Enum.TryParse(envir, out cEnvir);
            Dictionary<string, long> queueStatus = new Dictionary<string, long>();
            long numDone = await _prodService.QueueLenAsync(cEnvir, ProdQueueType.done);
            long numRun = await _prodService.QueueLenAsync(cEnvir, ProdQueueType.running);
            long numWait = await _prodService.QueueLenAsync(cEnvir, ProdQueueType.waiting);
            // simulo status...
            queueStatus.Add("waiting", numWait);
            queueStatus.Add("running", numRun);
            queueStatus.Add("done", numDone);
            sw.Stop();
            Log.Info($"QueueStatus | {sw.Elapsed.TotalMilliseconds:N3} ms");
            return Ok(queueStatus);
        }

        /// <summary>
        /// Chiamata GET:
        /// - fornisce il job da eseguire dalla coda (SE presente)
        /// GET: api/Prod/rep-answer/ABC012345
        /// </summary>
        /// <returns></returns>
        [HttpGet("rep-answer/{uid}")]
        public async Task<ActionResult<string>> ReplayAnswer(string uid, int env)
        {
            Constants.EXECENVIRONMENTS envir = (Constants.EXECENVIRONMENTS)env;
            string rawData = await EMProc.LoadRawData(uid, envir);
            bool saved = false;
            // provo a riprcessare...
            var retData = JsonConvert.DeserializeObject<AnswerDTO>(rawData);
            if (retData != null)
            {
                saved = await EMProc.ProcessAnswer(retData);
            }
            return Ok(rawData);
        }

        [HttpGet("version")]
        public string version()
        {
            var version = Assembly
                .GetExecutingAssembly()
                .GetName()
                .Version?
                .ToString() ?? "unknown";

            return version;
        }

        #endregion Public Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private readonly ICalcRuidService _calcRuidService;
        private IProdService _prodService;
        private ExternalMessageProcessor EMProc;

        #endregion Private Fields
    }
}