using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MP.TaskMan.Models;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static MP.TaskMan.Objects.Enums;

namespace MP.TaskMan.Controllers
{
    public class MpTaskController : IDisposable
    {
        #region Public Constructors

        public MpTaskController(IConfiguration configuration)
        {
            _configuration = configuration;
            Log.Info("Avviato MpTaskController");
        }

        #endregion Public Constructors

        #region Public Methods

        public DateTime CalcNextExe(TaskListModel taskRec)
        {
            DateTime dtNext = DateTime.Today;
            DateTime adesso = DateTime.Now;
            int maxIter = 1000;
            try
            {
                // prendo come partenza la DATA di fine a cui aggiungo l'ora/minuti schedulata precedentemente
                TimeSpan oraSched = taskRec.DtNextExec.Subtract(taskRec.DtNextExec.Date);
                DateTime baseDT = taskRec.DtLastExec.Date.Add(oraSched);
                // calcolo next exec da tipo... con ciclo fino a quando supero dataora attuale...
                while (dtNext < adesso && maxIter > 0)
                {
                    switch (taskRec.Freq)
                    {
                        case TaskFreqType.ND:
                            dtNext = baseDT.AddDays(taskRec.Cad);
                            break;

                        case TaskFreqType.Sec:
                            dtNext = baseDT.AddSeconds(taskRec.Cad);
                            break;

                        case TaskFreqType.Min:
                            dtNext = baseDT.AddMinutes(taskRec.Cad);
                            break;

                        case TaskFreqType.Hour:
                            dtNext = baseDT.AddHours(taskRec.Cad);
                            break;

                        case TaskFreqType.Day:
                            dtNext = baseDT.AddDays(taskRec.Cad);
                            break;

                        case TaskFreqType.Week:
                            dtNext = baseDT.AddDays(7 * taskRec.Cad);
                            break;

                        case TaskFreqType.Month:
                            dtNext = baseDT.AddMonths(taskRec.Cad);
                            break;

                        case TaskFreqType.Year:
                            dtNext = baseDT.AddYears(taskRec.Cad);
                            break;

                        default:
                            dtNext = baseDT.AddDays(taskRec.Cad);
                            break;
                    }
                    baseDT = dtNext;
                    maxIter--;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in CalcNextExe{Environment.NewLine}{exc}");
            }
            return dtNext;
        }

        public void Dispose()
        {
            _configuration = null;
        }

        /// <summary>
        /// Chiamata esecuzione di un singolo task programmato, SE in stato abilitato
        /// </summary>
        /// <param name="TaskId"></param>
        /// <param name="SchedNext">Se true rischedula successiva chiamata</param>
        /// <returns></returns>
        public TaskResultModel ExecuteSqlTask(int TaskId, bool SchedNext)
        {
            TaskResultModel callRes = new TaskResultModel();
            using (var dbCtx = new TaskContext(_configuration))
            {
                // imposto timeout a 5 min
                //var currTimeout = dbCtx.Database.GetCommandTimeout();
                dbCtx.Database.SetCommandTimeout(TimeSpan.FromMinutes(5));
                string sqlCall = "";
                try
                {
                    DateTime dtStart = DateTime.Now;
                    // recupero i dati da richiamare...
                    var currRec = dbCtx
                                .DbSetTaskList
                                .Where(x => x.TaskId == TaskId && x.Enabled)
                                .FirstOrDefault();
                    if (currRec != null)
                    {
                        // recupero comando
                        string sqlCommand = currRec.Command;
                        string rawParams = currRec.Args;
                        // salvo la call x eventuale log errore
                        sqlCall = $"EXEC {sqlCommand} {rawParams}";

                        var rawData = dbCtx
                                        .DbSetTaskResult
                                        .FromSqlRaw($"EXEC {sqlCommand} {rawParams}")
                                        .ToList();

                        callRes = rawData.FirstOrDefault() ?? new TaskResultModel();

                        DateTime dtEnd = DateTime.Now;

                        // preparo record esecuzione...
                        TaskExecModel resRec = new TaskExecModel()
                        {
                            TaskId = TaskId,
                            DtStart = dtStart,
                            DtEnd = dtEnd,
                            IsError = callRes.ExecResult < 0,
                            Result = callRes.TextResult
                        };
                        dbCtx
                            .DbSetTaskExe
                            .Add(resRec);

                        // aggiorno record chiamata...
                        currRec.DtLastExec = dtStart;
                        currRec.LastResult = resRec.Result;
                        currRec.LastIsError = resRec.IsError;
                        currRec.LastDuration = dtEnd.Subtract(dtStart).TotalSeconds;
                        // solo se richiesto rischedulazione ricalcola chiamata
                        if (SchedNext)
                        {
                            // calcolo prossima esecuzione...
                            currRec.DtNextExec = CalcNextExe(currRec);
                        }
                        // segno modificato
                        dbCtx.Entry(currRec).State = EntityState.Modified;

                        // salvo modifiche!
                        dbCtx.SaveChanges();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ExecuteSqlCommand{Environment.NewLine}Call eseguita:{Environment.NewLine}{sqlCall}{Environment.NewLine}------- Stack Eccezione -------{Environment.NewLine}{exc}");
                }
            }
            return callRes;
        }

        /// <summary>
        /// Annulla modifiche su una specifica entity (cancel update)
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool RollBackEntity(object item)
        {
            bool answ = false;
            using (var dbCtx = new TaskContext(_configuration))
            {
                try
                {
                    if (dbCtx.Entry(item).State == EntityState.Deleted || dbCtx.Entry(item).State == EntityState.Modified)
                    {
                        dbCtx.Entry(item).Reload();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Ricerca task dato tipo + num max (desc)
        /// </summary>
        /// <param name="TaskId">TaskId da cui deriva</param>
        /// <returns></returns>
        public List<TaskExecModel> TaskExecGetFilt(int TaskId, int maxRec)
        {
            List<TaskExecModel> dbResult = new List<TaskExecModel>();
            using (var dbCtx = new TaskContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetTaskExe
                    .Include(x => x.TaskListNav)
                    .Where(x => (x.TaskId == TaskId))
                    .OrderByDescending(x => x.DtStart)
                    .Take(maxRec)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Esegue registrazione di un Task generico (NON SQL)
        /// </summary>
        /// <param name="TaskId"></param>
        /// <param name="SchedNext">Se true rischedula successiva chiamata</param>
        /// <param name="ResRec">Record esecuzione task esterno</param>
        /// <returns></returns>
        public TaskResultModel TaskExecSaveExecuted(int TaskId, bool SchedNext, TaskExecModel ResRec)
        {
            TaskResultModel callRes = new TaskResultModel();
            using (var dbCtx = new TaskContext(_configuration))
            {
                try
                {
                    // recupero i dati da richiamare...
                    var currRec = dbCtx
                                .DbSetTaskList
                                .Where(x => x.TaskId == TaskId)
                                .FirstOrDefault();
                    if (currRec != null)
                    {
                        // registro task ricevuto
                        dbCtx
                            .DbSetTaskExe
                            .Add(ResRec);

                        // aggiorno record chiamata...
                        currRec.DtLastExec = ResRec.DtStart;
                        currRec.LastResult = ResRec.Result;
                        currRec.LastIsError = ResRec.IsError;
                        currRec.LastDuration = ResRec.DtEnd.Subtract(ResRec.DtStart).TotalSeconds;
                        // solo se richiesto rischedulazione ricalcola chiamata
                        if (SchedNext)
                        {
                            // calcolo prossima esecuzione...
                            currRec.DtNextExec = CalcNextExe(currRec);
                        }
                        // segno modificato
                        dbCtx.Entry(currRec).State = EntityState.Modified;

                        // salvo modifiche!
                        dbCtx.SaveChanges();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskExecSaveExecuted{Environment.NewLine}{exc}");
                }
            }
            return callRes;
        }

        /// <summary>
        /// Upsert record TaskExec
        /// </summary>
        /// <param name="rec2upd">Record da aggiornare/inserire</param>
        /// <returns></returns>
        public bool TaskExecUpsert(TaskExecModel rec2upd)
        {
            bool done = false;
            using (var dbCtx = new TaskContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetTaskExe
                        .Where(x => x.TaskExecId == rec2upd.TaskExecId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.TaskId = rec2upd.TaskId;
                        currData.DtStart = rec2upd.DtStart;
                        currData.DtEnd = rec2upd.DtEnd;
                        currData.IsError = rec2upd.IsError;
                        currData.Result = rec2upd.Result;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetTaskExe
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskExecUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Ricerca task dato tipo e
        /// </summary>
        /// <param name="TType"></param>
        /// <returns></returns>
        public List<TaskListModel> TaskListGetAll(Task2ExeType TType)
        {
            List<TaskListModel> dbResult = new List<TaskListModel>();
            using (var dbCtx = new TaskContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetTaskList
                    .Where(x => (TType == Task2ExeType.ALL || x.TType == TType))
                    .OrderBy(x => x.Ordinal)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Update ordinamento task
        /// </summary>
        /// <param name="rec2upd">Record da spostare x priorità</param>
        /// <returns></returns>
        public bool TaskListMove(TaskListModel rec2upd, bool moveUp)
        {
            bool done = false;
            using (var dbCtx = new TaskContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                                    .DbSetTaskList
                                    .Where(x => x.TaskId == rec2upd.TaskId)
                                    .FirstOrDefault();
                    if (currData != null)
                    {
                        int actOrdinal = currData.Ordinal;
                        TaskListModel? otherRec = null;
                        // cerco, secondo richiesta, precedente o successivo
                        if (moveUp)
                        {
                            otherRec = dbCtx
                                        .DbSetTaskList
                                        .Where(x => x.Ordinal < currData.Ordinal && x.Group==currData.Group)
                                        .OrderByDescending(x => x.Ordinal)
                                        .FirstOrDefault();
                        }
                        else
                        {
                            otherRec = dbCtx
                                        .DbSetTaskList
                                        .Where(x => x.Ordinal > currData.Ordinal && x.Group == currData.Group)
                                        .OrderBy(x => x.Ordinal)
                                        .FirstOrDefault();
                        }
                        // inverto ordinale SE ho record
                        if (otherRec != null)
                        {
                            currData.Ordinal = otherRec.Ordinal;
                            otherRec.Ordinal = actOrdinal;
                            dbCtx.Entry(currData).State = EntityState.Modified;
                            dbCtx.Entry(otherRec).State = EntityState.Modified;
                        }
                    }
                    //salvo
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskListUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Riordino record di un dato gruppo (da richiamare post cambio gruppo...)
        /// </summary>
        /// <param name="codGroup"></param>
        /// <returns></returns>
        public bool TaskListReorder(int codGroup)
        {
            bool done = false;
            using (var dbCtx = new TaskContext(_configuration))
            {
                // in primis recupero i record del gruppo ordinati
                var currList = dbCtx
                               .DbSetTaskList
                               .Where(x => x.Group == codGroup)
                               .OrderBy(x => x.Ordinal)
                               .ThenBy(x => x.TaskId)
                               .ToList();
                int newIdx = 0;
                int numRec = currList.Count;
                // li verifico in base al loro id attuale...
                foreach (var item in currList)
                {
                    newIdx++;
                    // se va cambiato lo riassegno
                    if (item.Ordinal != newIdx)
                    {
                        item.Ordinal = newIdx;
                        dbCtx.Entry(item).State = EntityState.Modified;
                    }
                }
                // salvo!
                try
                {
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskListReorder{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Upsert record TaskList
        /// </summary>
        /// <param name="rec2upd">Record da aggiornare/inserire</param>
        /// <returns></returns>
        public bool TaskListUpsert(TaskListModel rec2upd)
        {
            bool done = false;
            using (var dbCtx = new TaskContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetTaskList
                        .Where(x => x.TaskId == rec2upd.TaskId && rec2upd.TaskId > 0)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.Ordinal = rec2upd.Ordinal;
                        currData.Group = rec2upd.Group;
                        currData.Enabled = rec2upd.Enabled;
                        currData.Name = rec2upd.Name;
                        currData.Descript = rec2upd.Descript;
                        currData.Command = rec2upd.Command;
                        currData.Args = rec2upd.Args;
                        currData.Freq = rec2upd.Freq;
                        currData.Cad = rec2upd.Cad;
                        currData.DtLastExec = rec2upd.DtLastExec;
                        currData.DtNextExec = rec2upd.DtNextExec;
                        currData.LastDuration = rec2upd.LastDuration;
                        currData.LastResult = rec2upd.LastResult;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetTaskList
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskListUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        #endregion Public Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Private Properties

        private static IConfiguration _configuration { get; set; } = null!;

        #endregion Private Properties
    }
}