using Step.Model.DatabaseModels;
using Step.Model.DTOModels;
using Step.Model.DTOModels.MaintenanceModels;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.IO;
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 PerformedMaintenanceModel PerformeMaintenance(uint counterValue, int maintenanceId, int userId)
        {
            PerformedMaintenanceModel performed = new PerformedMaintenanceModel()
            {
                CounterValue = (int)counterValue,
                Date = DateTime.Now,
                MaintenanceId = maintenanceId,
                MaintainerId = userId
            };

            dbCtx.PerformedMaintenances.Add(performed);

            // Commit changes
            dbCtx.SaveChanges();

            return performed;
        }

        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()
            {
                MaintenanceId = GetUserMaintenanceId(dbCtx.Maintenances),
                CreationDate = DateTime.Now,
                CounterId = 0,
                Interval = newMaint.Interval,
                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;
        }

        private int GetUserMaintenanceId(IEnumerable<MaintenanceModel> maintenances)
        {
            int max = maintenances.Select(x => x.MaintenanceId).Max();
            // If there aren't user maintenance return 100
            if (max < 100)
                return 100;
            else
                return max + 1;
        }

        public MaintenanceModel Update(int maintenanceId, DTOUpdateMaintenanceModel newMaint)
        {
            MaintenanceModel dbMaint = FindById(maintenanceId);

            if (dbMaint != null)
            {
                dbMaint.Title = newMaint.Title;
                dbMaint.Description = newMaint.Description;
                dbMaint.Deadline = newMaint.Deadline;
                dbMaint.Interval = newMaint.Interval;
                dbMaint.UnitOfMeasure = newMaint.UnitOfMeasure;

                // Commit changes
                dbCtx.SaveChanges();
            }

            return dbMaint;
        }

        public void Delete(int maintId)
        {
            MaintenanceModel maint = FindById(maintId);
            Delete(maint);
        }

        public void Delete(MaintenanceModel maint)
        {
            dbCtx.Maintenances.Remove(maint);
            dbCtx.SaveChanges();
        }

        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 = (MAINTENANCE_TYPE)Enum.Parse(typeof(MAINTENANCE_TYPE), x.Type);
                        old.CounterId = x.CouterId;
                        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 = (MAINTENANCE_TYPE)Enum.Parse(typeof(MAINTENANCE_TYPE), x.Type),
                    CounterId = x.CouterId,
                    CreationDate = DateTime.Now,
                    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();
            }
        }

        #region Notes

        public MaintenanceNoteModel FindNoteById(int noteId)
        {
            return dbCtx
                .MaintenancesNotes
                .Where(x => x.Id == noteId)
                .Include("User")
                .FirstOrDefault();
        }

        public List<MaintenanceNoteModel> FindNotes()
        {
            return dbCtx
                .MaintenancesNotes
                .ToList();
        }

        public List<DTOMaintenanceNoteModel> GetNotesByMaintId(int maintenanceId)
        {
            return dbCtx
                .MaintenancesNotes
                .Where(x => x.MaintenanceId == maintenanceId) // Filter by id
                .Select(x => new DTOMaintenanceNoteModel() // Convert to return model
                {
                    Id = x.Id,
                    DateTime = x.DateTime,
                    Message = x.Message,
                    User = new DTOMessageUserModel()
                    {
                        Id = x.User.UserId,
                        FirstName = x.User.FirstName,
                        LastName = x.User.LastName,
                        Username = x.User.Username
                    }
                })
                .ToList();
        }

        public DTOMaintenanceNoteModel CreateNote(int userId, int maintenanceId, DTONewMaintenanceNoteModel newNote)
        {
            // Create model
            MaintenanceNoteModel note = new MaintenanceNoteModel()
            {
                Message = newNote.Message,
                DateTime = DateTime.Now,
                MaintenanceId = maintenanceId,
                UserId = userId
            };
            // Add & save into database
            dbCtx.MaintenancesNotes.Add(note);

            dbCtx.SaveChanges();

            dbCtx.Entry(note).Reference(x => x.User).Load();
            dbCtx.Users.Attach(note.User);

            return (DTOMaintenanceNoteModel)note;
        }

        public DTOMaintenanceNoteModel UpdateNote(MaintenanceNoteModel note, DTONewMaintenanceNoteModel newNote)
        {
            note.Message = newNote.Message;
            dbCtx.SaveChanges();

            return (DTOMaintenanceNoteModel)note;
        }

        public void DeleteNote(int noteId)
        {
            MaintenanceNoteModel note = FindNoteById(noteId);
            dbCtx.MaintenancesNotes.Remove(note);

            dbCtx.SaveChanges();
        }

        #endregion Notes

        #region Attachment

        public List<MaintenanceFileModel> FindAttachmentByMaintenance(int maintenanceId)
        {
            return dbCtx
                .MaintenanceFiles
                .Where(x => x.MaintenanceId == maintenanceId)
                .ToList();
        }

        public MaintenanceFileModel FindAttachmentById(int attachmentId)
        {
            return dbCtx
                .MaintenanceFiles
                .Where(x => x.AttachmentId == attachmentId)
                .FirstOrDefault();
        }

        public MaintenanceFileModel AddAttachment(string fileName, string localFileName, int maintenanceId, int userId)
        {
            MaintenanceFileModel file = new MaintenanceFileModel()
            {
                FileName = fileName,
                LocalFileName = localFileName,
                MaintenanceId = maintenanceId,
                UserId = userId
            };
            // Add to db
            dbCtx.MaintenanceFiles.Add(file);

            dbCtx.SaveChanges();

            return file;
        }

        public void DeleteAttachment(int attachmentId)
        {
            MaintenanceFileModel file = dbCtx.MaintenanceFiles.Where(x => x.AttachmentId == attachmentId).FirstOrDefault();
            if (file != null)
            {
                dbCtx.MaintenanceFiles.Remove(file);

                dbCtx.SaveChanges();
            }
        }

        public void DeleteAttachment(MaintenanceFileModel attachment)
        {
            dbCtx.MaintenanceFiles.Remove(attachment);

            dbCtx.SaveChanges();

            if (File.Exists(MAINTENANCE_ATTACHMENT_PATH + attachment.LocalFileName))
                File.Delete(MAINTENANCE_ATTACHMENT_PATH + attachment.LocalFileName);
        }

        #endregion Attachment
    }
}