using GWMS.Data.DatabaseModels;
using GWMS.Data.DTO;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;

namespace GWMS.Data.Controllers
{
    public class GWMSController : IDisposable
    {
        #region Private Fields

        private static IConfiguration _configuration;
        private static GWMSContext dbCtx;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Public Constructors

        public GWMSController(IConfiguration configuration)
        {
            _configuration = configuration;
            dbCtx = new GWMSContext(configuration);
            Log.Info("Avviata classe GWMSController");
        }

        #endregion Public Constructors

        #region Private Methods

        private void CreateSimData()
        {
            ResetController();
            // generazione dati casuale
            Random rnd = new Random();
            foreach (var plant in GetPlants())
            {
                var currPlant = GetPlant(plant.PlantId);
                // imposto limiti e valori attuali...
                currPlant.LevelMax = rnd.Next(22, 30) * 1000;
                var simLevel = rnd.Next(1, (int)currPlant.LevelMax);
                currPlant.LevelAct = simLevel;
                dbCtx.SaveChanges();

                // genero random le soglie x simulare rilievi e ordini
                int soglia01 = rnd.Next((int)currPlant.LevelMax * 60 / 100, (int)currPlant.LevelMax * 75 / 100);
                int soglia02 = rnd.Next((int)currPlant.LevelMax * 5 / 100, (int)currPlant.LevelMax * 35 / 100);

                List<PlantLogModel> LogLevels = new List<PlantLogModel>();
                List<OrderModel> LogOrders = new List<OrderModel>();

                DateTime adesso = DateTime.Now;
                int lastLevel = simLevel;
                int lastOrder = 0;
                int stepMin = 30;
                int maxHourRate = 800;
                int anticipo = 0;
                // simulo 7 gg...
                for (int i = 7 * 24 * (60 / stepMin); i > 0; i--)
                {
                    anticipo = i * stepMin;
                    lastLevel = lastLevel - rnd.Next(0, maxHourRate / (60 / stepMin));
                    // se inferiore a soglia 1 --> ordine
                    if (lastLevel + lastOrder < soglia01)
                    {
                        lastOrder = rnd.Next((int)currPlant.LevelMax - soglia01, (int)currPlant.LevelMax - soglia02);
                        LogOrders.Add(new OrderModel() { DtOrder = adesso.AddMinutes(-anticipo), OrderQty = lastOrder, PlantId = plant.PlantId, OrderCode = $"ORD{i:000000}", OrderDesc = "SIM Order", SupplierId = 1, TransporterId = 1 });
                    }

                    // se inferiore a soglia 2 --> refill
                    if (lastLevel < soglia02)
                    {
                        lastLevel += lastOrder;
                        lastOrder = 0;
                    }
                    LogLevels.Add(new PlantLogModel() { DtEvent = adesso.AddMinutes(-anticipo), FluxType = "Level", PlantId = plant.PlantId, ValNumber = lastLevel });
                }

                try
                {
                    dbCtx
                        .DbSetPlantLog
                        .AddRange(LogLevels);

                    // salvo sul DB!
                    dbCtx.SaveChanges();
                    Log.Info($"Effettuato inserimento {LogLevels.Count} record PlantLog");
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in salvataggio PlantLog{Environment.NewLine}{exc}");
                }
                try
                {
                    dbCtx
                        .DbSetOrders
                        .AddRange(LogOrders);

                    // salvo sul DB!
                    dbCtx.SaveChanges();
                    Log.Info($"Effettuato inserimento {LogOrders.Count} record Orders");
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in salvataggio Orders{Environment.NewLine}{exc}");
                }
            }
        }

        #endregion Private Methods

        #region Public Methods

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
        }

        public List<DatabaseModels.ConfigModel> GetConfig()
        {
            var dbResult = dbCtx
                .DbSetConfig
                .ToList();

            return dbResult;
        }

        public List<DatabaseModels.ItemModel> GetItems()
        {
            var dbResult = dbCtx
                .DbSetItems
                .ToList();

            return dbResult;
        }

        public List<DatabaseModels.OrderModel> GetOrdersFilt(int PlantId)
        {
            var dbResult = dbCtx
                .DbSetOrders
                .Where(x => (x.PlantId == PlantId || PlantId == 0))
                .Include(p => p.Plant)
                .Include(s => s.Supplier)
                .Include(t => t.Transporter)
                .OrderByDescending(x => x.DtOrder)
                .ToList();

            return dbResult;
        }

        public DatabaseModels.PlantDetailModel GetPlant(int PlantId)
        {
            var dbResult = dbCtx
                .DbSetPlant
                .Where(x => x.PlantId == PlantId)
                .FirstOrDefault();

            return dbResult;
        }

        public List<DatabaseModels.PlantDetailModel> GetPlants()
        {
            var dbResult = dbCtx
                .DbSetPlant
                .ToList();

            return dbResult;
        }

        public List<PlantDTO> GetPlantsDTO()
        {
            var plantList = dbCtx
                .DbSetPlant
                .ToList();

            var dbResult = plantList
                .Select(x => PlantDTO(x.PlantId))
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Recupero info PLANT modalità DTO
        /// </summary>
        /// <param name="PlantId"></param>
        /// <returns></returns>
        public PlantDTO PlantDTO(int PlantId)
        {
            var currPlant = GetPlant(PlantId);

            List<TSData> LevelTS = new List<TSData>();
            List<TSData> OrderTS = new List<TSData>();
            // recupero dal DB
            var rawLevelData = dbCtx
                                .DbSetPlantLog
                                .Where(x => x.FluxType == "Level" && x.PlantId == PlantId)
                                .OrderBy(x => x.DtEvent)
                                .ToList();

            var rawOrderData = dbCtx
                                .DbSetOrders
                                .Where(x => x.PlantId == PlantId)
                                .OrderBy(x => x.DtOrder)
                                .ToList();

            LevelTS = rawLevelData
                        .Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();

            OrderTS = rawOrderData
                        .Select(x => new TSData() { DtEvent = x.DtOrder, ValDouble = x.OrderQty }).ToList();

            PlantDTO answ = new PlantDTO()
            {
                PlantId = PlantId,
                PlantCode = currPlant.PlantCode,
                PlantDesc = currPlant.PlantDesc,
                LevelAct = currPlant.LevelAct,
                LevelMax = currPlant.LevelMax,
                LevelTS = LevelTS,
                OrderTS = OrderTS
            };
            return answ;
        }

        /// <summary>
        /// Rigenera intero DB se riceve ID di un plant SIM...
        /// </summary>
        /// <param name="PlantId"></param>
        public bool RegenDB(int PlantId)
        {
            bool answ = false;
            var currPlant = GetPlant(PlantId);
            if (currPlant.PlantCode.StartsWith("PSIM"))
            {
                Log.Info("Inizio RegenDB");
                // rigenero intero DB
                dbCtx.Database.EnsureDeleted();
                Log.Info("DB Eliminato");

                dbCtx.Database.EnsureCreated();
                Log.Info("DB Inizializzato");

                ResetController();

                CreateSimData();
                Log.Info("Dati SIM generati");

                answ = true;
            }
            return answ;
        }

        public void ResetController()
        {
            dbCtx = new GWMSContext(_configuration);
        }

        #endregion Public Methods
    }
}