using Step.Model.DatabaseModels;
using Step.Model.DTOModels.ToolModels;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

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

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

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

        public List<NcFamilyModel> FindFamilies()
        {
            List<NcFamilyModel> families = dbCtx
                .Families
                .Include("Tools")
                .ToList();

            return families;
        }

        public List<DTONcFamilyModel> GetFamilies()
        {
            List<NcFamilyModel> dbFamilies = FindFamilies();

            return dbFamilies
                .Select(x => (DTONcFamilyModel)x)
                .ToList();
        }

        public NcToolModel FindTool(int toolId)
        {
            return dbCtx.Tools
                .Where(x => x.ToolId == toolId)
                .FirstOrDefault();
        }

        public NcShankModel FindShank(int shankId)
        {
            return dbCtx.Shanks
                .Include("Tools")
                .Where(x => x.ShankId == shankId)
                .FirstOrDefault();
        }

        public NcFamilyModel FindFamily(int familyId)
        {
            return dbCtx
                .Families
                .Where(x => x.FamilyId == familyId)
                .FirstOrDefault();
        }

        public List<NcToolModel> FindToolsWithDependencies()
        {
            List<NcToolModel> tools = dbCtx
                .Tools
                .Include("Family")
                .Include("Shank")
                .ToList();

            return tools;
        }

        public List<NcToolModel> FindTools()
        {
            List<NcToolModel> tools = dbCtx
                .Tools
                .ToList();

            return tools;
        }

        public List<DTONcToolModel> GetTools()
        {
            List<NcToolModel> dbTools = FindToolsWithDependencies();

            return dbTools
                .Select(x => (DTONcToolModel)x)
                .ToList();
        }

        public List<NcShankModel> FindShanks()
        {
            List<NcShankModel> shanks = dbCtx
                .Shanks
                .Include("MagazinePosition")
                .ToList();

            return shanks;
        }

        public List<DTONcShankModel> GetShanks()
        {
            // Get shank from database
            List<NcShankModel> dbShanks = dbCtx
                .Shanks
                .Include("Tools")
                .ToList();

            // Populate db shanks
            List<DTONcShankModel> dtoShanks = dbShanks
                .Select(x => (DTONcShankModel)x)
                .ToList();
            //    new List<DTONcShankModel>();
            //foreach (var shank in dbShanks)
            //{
            //    //dbCtx.Shanks.Attach(shank);
            //    DTONcShankModel dtoShank = (DTONcShankModel)shank;

            //    dtoShanks.Add(dtoShank);
            //}

            return dtoShanks;
        }

        public DTONcShankModel GetShank(int shankId)
        {
            // Get shank from database
            NcShankModel dbShank = dbCtx
                .Shanks
                .Where(x => x.ShankId == shankId)
                .Include("Tools")
                .FirstOrDefault();

            // Convert into DTOModel
            DTONcShankModel dtoShanks = (DTONcShankModel)dbShank;

            return dtoShanks;
        }

        public List<NcMagazinePositionModel> FindPositions()
        {
            List<NcMagazinePositionModel> positions = dbCtx
                .MagazinePositions
                .ToList();

            return positions;
        }

        public List<NcMagazinePositionModel> FindMagazinePositions(byte magId)
        {
            return dbCtx
                .MagazinePositions
                .Where(x => x.MagazineId == magId)
                .ToList();
        }


        public List<DTONcMagazinePositionModel> GetMagazinePositions(byte magId)
        {
            // Get only magazine positions that match with magazineId
            List<DTONcMagazinePositionModel> magPos = FindMagazinePositions(magId).Select(x => (DTONcMagazinePositionModel)x).ToList();
            // Get&filter shanks by magazineId in order to get only mounted shanks in the current magazineId
            List<NcShankModel> shanks = dbCtx.Shanks.Where(x => x.MagazineId == magId).ToList();
            
            foreach(NcShankModel shank in shanks)
            {
                // Populate magazinePosition shank Id
                magPos
                    .Where(x => x.PositionId == shank.PositionId)
                    .FirstOrDefault()
                    .ShankId = shank.ShankId;
            }
            // Convert in DTOModel and return
            return magPos;
        }

        public NcMagazinePositionModel FindMagazinePosition(byte magId, byte posId)
        {
            NcMagazinePositionModel positions = dbCtx
                .MagazinePositions
                .Where(x => x.MagazineId == magId && x.PositionId == posId)
                .FirstOrDefault();

            return positions;
        }

        public List<DTONcShankModel> GetMountedShanks(int magazineId)
        {
            List<DTONcShankModel> dtoShanks = GetShanks()
                 .Where(x => x.MagazineId != null)
                 .ToList();

            return dtoShanks;
        }

        public List<DTONcShankModel> GetAvailableShanks()
        {
            List<DTONcShankModel> dtoShanks = GetShanks()
                .Where(x => x.MagazineId == null && x.Tools.Count > 0)
                .ToList();

            return dtoShanks;
        }

        public NcToolModel AddTool(DTONewNcToolModel dtoTool)
        {
            NcToolModel tool = (NcToolModel)dtoTool;
            dbCtx.Tools.Add(tool);

            dbCtx.SaveChanges();
            // Get foreign key data
            dbCtx.Entry(tool).Reference(x => x.Family).Load();
            dbCtx.Entry(tool).Reference(x => x.Shank).Load();

            return tool;
        }

        public NcToolModel UpdateTool(int toolId, DTONewNcToolModel dtoTool)
        {
            NcToolModel tool = FindTool(toolId);
            // Update db model
            tool.FamilyId = dtoTool.FamilyId;
            tool.Type = dtoTool.Type;
            tool.OffsetLength = dtoTool.OffsetLength;
            tool.ResidualLife = dtoTool.ResidualLife;
            tool.ResidualRevive = dtoTool.ResidualRevive;
            tool.OffsetId1 = dtoTool.OffsetId1;
            tool.OffsetId2 = dtoTool.OffsetId2;
            tool.OffsetId3 = dtoTool.OffsetId3;
            // Save
            dbCtx.SaveChanges();

            return tool;
        }

        public void DeleleTool(int toolId)
        {
            NcToolModel tool = FindTool(toolId);
            DeleteTool(tool);
        }

        public void DeleteTool(NcToolModel tool)
        {
            dbCtx.Tools.Remove(tool);

            dbCtx.SaveChanges();
        }

        public NcFamilyModel AddFamily(DTONewNcFamilyModel family)
        {
            NcFamilyModel dbFamily = (NcFamilyModel)family;
            dbCtx.Families.Add(dbFamily);

            dbCtx.SaveChanges();
            dbCtx.Families.Attach(dbFamily);

            return dbFamily;
        }

        public NcFamilyModel UpdateFamily(int familyId, DTONewNcFamilyModel family)
        {
            NcFamilyModel dbFamily = FindFamily(familyId);
            dbFamily = (NcFamilyModel)family;

            dbCtx.SaveChanges();
            dbCtx.Families.Attach(dbFamily);

            return dbFamily;
        }
        
        public void DeleteFamily(NcFamilyModel family)
        {
            dbCtx.Families.Attach(family);
            dbCtx.Families.Remove(family);

            dbCtx.SaveChanges();
        }
        
        public NcShankModel AddShank(DTONewNcShankModel shank)
        {
            NcShankModel dbShank = (NcShankModel)shank;
            dbCtx.Shanks.Add(dbShank);

            dbCtx.SaveChanges();

            dbCtx.Shanks.Attach(dbShank);

            return dbShank;
        }

        public NcShankModel UpdateShank(int shankId, DTONewNcShankModel dtoShank)
        {
            NcShankModel ncShank = FindShank(shankId);

            return UpdateShank(ncShank, dtoShank);
        }

        public NcShankModel UpdateShank(NcShankModel dbShank, DTONewNcShankModel dtoShank)
        {
            dbShank.MagazinePositionType = dtoShank.MagazinePositionType;

            dbCtx.SaveChanges();
            
            dbCtx.Shanks.Attach(dbShank);

            return dbShank;
        }
        
        public void DeleteShank(int shankId)
        {
            NcShankModel shank = FindShank(shankId);
            DeleteShank(shank);
        }
        
        public void DeleteShank(NcShankModel shank)
        {
            dbCtx.Shanks.Attach(shank);
            dbCtx.Shanks.Remove(shank);

            dbCtx.SaveChanges();
        }

        public NcMagazinePositionModel UpdatePosition(NcMagazinePositionModel dbPos, DTONcMagazinePositionModel dtoPos)
        {
            dbPos.Type = dtoPos.Type;
            dbPos.Disabled = dtoPos.Disabled;

            dbCtx.SaveChanges();

            return dbPos;
        }

        public NcMagazinePositionModel LoadShankInMagazine(byte magazineId, byte positionId, NcShankModel shank)
        {
            dbCtx.Shanks.Attach(shank);

            shank.MagazineId = magazineId;
            shank.PositionId = positionId;

            dbCtx.SaveChanges();

            return FindMagazinePosition(magazineId, positionId);
        }

        public DTONcShankModel UnloadShankInMagazine(byte magazineId, byte positionId, NcShankModel shank)
        {
            dbCtx.Shanks.Attach(shank);

            shank.MagazineId = null;
            shank.PositionId = null;

            dbCtx.SaveChanges();

            return (DTONcShankModel)shank;
        }

        public DTONcShankModel LoadToolIntoShank(NcToolModel tool, int shankId)
        {
            dbCtx.Tools.Attach(tool);

            tool.ShankId = shankId;

            dbCtx.SaveChanges();

            return GetShank(shankId);
        }

        public DTONcShankModel UnloadToolFromShank(NcToolModel tool)
        {
            dbCtx.Tools.Attach(tool);
            int? shankId = tool.ShankId;

            tool.ShankId = null;

            dbCtx.SaveChanges();

            return GetShank(shankId.Value);
        }
    }
}