using Step.Model.DatabaseModels;
using Step.Model.DTOModels.MaintenanceModels;
using System;
using System.Collections.Generic;
using System.Linq;
using static Step.Config.ServerConfig;
using static Step.Model.Constants;

namespace Step.Database.Controllers
{
    public class MaintenancesController : IDisposable
    {
        private DatabaseContext dbCtx;

        public MaintenancesController()
        {
            // Initialize database context
            dbCtx = new DatabaseContext();
        }

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

        public List<PerformedMaintenanceModel> FindLastPerformedMaintenances()
        {
            List<PerformedMaintenanceModel> lastMaintenances = new List<PerformedMaintenanceModel>();
            // Find last performed maintenance
            lastMaintenances = (from maintenances in dbCtx.PerformedMaintenances
                                where maintenances.Date == (from m1 in dbCtx.PerformedMaintenances // Select max data of performed maintenance
                                                            where m1.MaintenanceId == maintenances.MaintenanceId
                                                            select m1.Date
                                                            ).Max()
                                select maintenances).ToList();

            return lastMaintenances;
        }

        public MaintenanceModel FindById(int id)
        {
            return dbCtx
                .Maintenances
                .Find(id);
        }

        public List<MaintenanceModel> FindAll()
        {
            return dbCtx
                .Maintenances
                .ToList();
        }

        public MaintenanceModel Create(DTONewMaintenanceModel newMaint, int userId)
        {
            MaintenanceModel dbMaint = new MaintenanceModel()
            {
                CreationDate = DateTime.Now,
                CounterId = 0,
                Interval = newMaint.Interval != null ? (double)newMaint.Interval : 0,
                Deadline = newMaint.Deadline,
                Description = newMaint.Description,
                Title = newMaint.Title,
                Type = newMaint.Type,
                UnitOfMeasure = newMaint.UnitOfMeasure,
                UserId = userId,
                LastExpirationDate = null
            };

            // Add to database
            dbCtx.Maintenances.Add(dbMaint);
            // Commit changes
            dbCtx.SaveChanges();

            return dbMaint;
        }
        
        public void CheckDifferencesFromDbAndXml()
        {
            List<MaintenanceModel> dbMaintenances = dbCtx
                .Maintenances
                .ToList();

            // Find database rows that has to be deleted
            List<MaintenanceModel> toDeleteMaint = dbMaintenances.Where(x => x.UserId == null && 
                !MaintenancesConfig.Select(y => y.Id).Contains(x.MaintenanceId)
            ).ToList();

            // Delete database items
            foreach (var item in toDeleteMaint)
                dbCtx.Maintenances.Remove(item);
            dbCtx.SaveChanges();

            // Find common data from
            List<MaintenanceModel> toUpdateMaint = dbMaintenances.Where(x =>
                MaintenancesConfig.Select(y => y.Id).Contains(x.MaintenanceId)
            )
            .ToList();

            // Update rows
            if (toUpdateMaint != null)
                foreach (MaintenanceModel item in toUpdateMaint)
                {
                    // find to update into db
                    var old = dbCtx.Maintenances.Where(x => x.MaintenanceId == item.MaintenanceId).FirstOrDefault();

                    // Update model
                    old = MaintenancesConfig.Where(x => x.Id == item.MaintenanceId).Select(x =>
                    {
                        old.MaintenanceId = x.Id;
                        old.Deadline = x.Deadline;
                        old.Interval = x.Intervall.TotalMinutes;
                        old.Type = x.Type;
                        old.CounterId = x.CouterId;
                        old.Description = x.Description;
                        old.UnitOfMeasure = (MAINTENANCE_UNIT_OF_MEASURE)Enum.Parse(typeof(MAINTENANCE_UNIT_OF_MEASURE), x.UnitOfMeasure);
                        return old;
                    }).FirstOrDefault();
                }

            dbCtx.SaveChanges();

            // Get new maintenance from file
            List<MaintenanceModel> toAddMaint = MaintenancesConfig
                .Where(x => !toUpdateMaint.Select(y => y.MaintenanceId).Contains(x.Id))
                .Select(x => new MaintenanceModel()
                {
                    MaintenanceId = x.Id,
                    Deadline = x.Deadline,
                    Interval = x.Intervall.TotalMinutes,
                    Type = x.Type,
                    CounterId = x.CouterId,
                    CreationDate = DateTime.Now,
                    Description = x.Description,
                    UnitOfMeasure = (MAINTENANCE_UNIT_OF_MEASURE) Enum.Parse(typeof(MAINTENANCE_UNIT_OF_MEASURE),x.UnitOfMeasure),
                    UserId = null,
                    LastExpirationDate = null
                })
                .ToList();

            // Add new maintenances to database
            if (toAddMaint != null)
            {
                dbCtx.Maintenances.AddRange(toAddMaint);
                dbCtx.SaveChanges();
            }
        }

        public void UpdateLastExpirationDate(int id, DateTime expDate)
        {
            MaintenanceModel maintenance = FindById(id);

            if (maintenance != null)
            {
                maintenance.LastExpirationDate = expDate;
                dbCtx.SaveChanges();
            }
        }
    }
}