using CMS_CORE_Library.Models;
using Newtonsoft.Json;
using Step.Database.Controllers;
using Step.Model.DatabaseModels;
using Step.Model.DTOModels;
using Step.Model.DTOModels.ToolModels;
using Step.NC;
using Step.Utils;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;
using static Step.Config.ServerConfig;
using static Step.Listeners.SignalRStaticObjects;
using static Step.Model.Constants;

namespace Step.Controllers.WebApi
{
    [RoutePrefix("api/tool_manager/nc")]
    public class NcToolManagerApiController : ApiController
    {
        #region Tools

        [Route("tools"), HttpGet]
        public IHttpActionResult GetNcToolTable()
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();
                CmsError cmsError = ncAdapter.GetToolsData(true, out List<DTONcToolModel> tools);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                // Add family data to tools
                using (NcToolManagerController toolsManager = new NcToolManagerController())
                {
                    // Get families
                    List<DTONcFamilyModel> families = toolsManager.GetFamilies();

                    List<DTONcToolWithFamilyModel> toolsWithFamilies = new List<DTONcToolWithFamilyModel>();
                    // Create tool&family return objecs
                    foreach (var tool in tools)
                    {
                        toolsWithFamilies.Add
                            (
                                CreateToolAndFamilyObj( // Create return model with family data & tool data
                                    tool,
                                    families.Where(x => x.Id == tool.FamilyId).FirstOrDefault() // Find matching family
                                    )
                            );
                    }

                    return Ok(toolsWithFamilies);
                }
            }
        }

        [Route("tools_without_offsets"), HttpGet]
        public IHttpActionResult GetNcToolTableWithoutOffset()
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();
                CmsError cmsError = ncAdapter.GetToolsData(false, out List<DTONcToolModel> tools);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                // Add family data to tools
                using (NcToolManagerController toolsManager = new NcToolManagerController())
                {
                    // Get families
                    List<DTONcFamilyModel> families = toolsManager.GetFamilies();

                    List<DTONcToolWithFamilyModel> toolsWithFamilies = new List<DTONcToolWithFamilyModel>();
                    // Create tool&family return objecs
                    foreach (var tool in tools)
                    {
                        toolsWithFamilies.Add
                            (
                                CreateToolAndFamilyObj( // Create return model with family data & tool data
                                    tool,
                                    families.Where(x => x.Id == tool.FamilyId).FirstOrDefault() // Find matching family
                                    )
                            );
                    }

                    return Ok(toolsWithFamilies);
                }
            }
        }

        [Route("tool/{toolId:int}/{familyId:int}"), HttpPost]
        public IHttpActionResult AddToolWithId(short toolId, short familyId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if exists a tool with the same id
                DbNcToolModel dbTool = toolsManager.FindTool(toolId);
                if (dbTool != null)
                    return BadRequest(API_ERROR_KEYS.ID_ALREADY_EXIST);

                // Create default family
                DTONcFamilyModel defaultFamily = new DTONcFamilyModel();
                // Copy data from static obj preconfigured
                SupportFunctions.CopyProperties(DTO_TOOL_WITH_FAM, defaultFamily);

                // Overwrite the custom model id
                defaultFamily.Id = familyId;

                // Check if FAMILY option is active
                if (ToolManagerConfig.FamilyOpt)
                {
                    // Check if id is already occupied
                    DbNcFamilyModel dbFam = null;

                    // Check Family id
                    // 0 : Create new family
                    // N : Set tool familyId with input id

                    if (familyId == 0)
                        // Add new family
                        dbFam = toolsManager.AddFamily(defaultFamily);
                    else
                    {
                        // check if family exist & set da
                        dbFam = toolsManager.FindFamily(familyId);
                        if (dbFam == null)
                            return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                    }

                    // Set return value
                    //DTO_TOOL_WITH_FAM.FamilyId = dbFam.FamilyId;
                    //DTO_TOOL_WITH_FAM.Name = dbFam.Name;

                    SupportFunctions.CopyProperties(dbFam, DTO_TOOL_WITH_FAM);
                }
                else
                {
                    defaultFamily.Id = toolId;
                    // Add new family
                    DbNcFamilyModel dbFam = toolsManager.AddFamily(defaultFamily);

                    // Set return value
                    DTO_TOOL_WITH_FAM.FamilyId = dbFam.FamilyId;
                    DTO_TOOL_WITH_FAM.Name = dbFam.Name;
                }

                // Check if  option is active
                if (!ToolManagerConfig.ShankOpt)
                {
                    // If option is not active create a shank
                    DTONewNcShankModel newShank = new DTONewNcShankModel()
                    {
                        Balluf = 0,
                        MagazinePositionType = 0
                    };

                    // Create a new shank
                    DbNcShankModel ncShank = toolsManager.AddShank(newShank, toolId);
                    // Connect tool to new shank
                    DTO_TOOL_WITH_FAM.ShankId = ncShank.ShankId;
                }
                else
                    DTO_TOOL_WITH_FAM.ShankId = null;
            }

            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                // Add tool
                CmsError cmsError = ncAdapter.AddTool(DTO_TOOL_WITH_FAM, out DTONcToolModel newTool, toolId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                // if offset option is disabled set first offset id equal to toolId
                if (!ToolManagerConfig.OffsetOpt)
                {
                    ncAdapter.UpdateToolOffsetId(newTool.Id, 1, newTool.Id, out DTONcToolModel toolWithOffset);
                    newTool.OffsetId1 = newTool.Id;
                    newTool.Offset1 = toolWithOffset.Offset1;
                }

                return Ok(CreateToolAndFamilyObj(newTool, DTO_TOOL_WITH_FAM));
            }
        }

        [Route("tool/{toolId:int}"), HttpPut]
        public IHttpActionResult PutTool(int toolId, [FromBody][Required]DTONewNcToolWithFamilyModel dtoToolWithFamily)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState); 

            DbNcToolModel tool = null;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if tool exists
                tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return NotFound();

                // Check if tool is mounted in spindle
                if (ToolIsInSpindle(toolId))
                    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                if (tool.FamilyId != dtoToolWithFamily.FamilyId)
                {
                    // Check if family exists
                    DbNcFamilyModel fam = toolsManager.FindFamily(dtoToolWithFamily.FamilyId);
                    if (fam == null)
                        return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                    // Change return fam data
                    if (ToolManagerConfig.FamilyOpt)
                    {
                        dtoToolWithFamily.Name = fam.Name;
                    }
                }

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    ncAdapter.Connect();

                    // Update
                    CmsError cmsError = ncAdapter.UpdateTool(toolId, dtoToolWithFamily, out DTONcToolModel newTool, dtoToolWithFamily);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(CreateToolAndFamilyObj(newTool, dtoToolWithFamily));
                }
            }
        }

        [Route("tool/{toolId:int}"), HttpDelete]
        public IHttpActionResult DeleteTool(int toolId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                DbNcToolModel tool = toolsManager.FindToolWithDependencies(toolId);
                if (tool == null)
                    return NotFound();

                // Check if tool is mounted in magazine (a tool to be mounted in spindle must be in magazine)
                if(tool.Shank != null && tool.Shank.MagazineId != null && tool.Shank.PositionId != null)
                    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                // Check if tool is mounted in spindle
                //if (ToolIsInSpindle(toolId))
                //    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    ncAdapter.Connect();

                    CmsError cmsError;
                    cmsError = ncAdapter.DeleteNcTool(tool);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok();
                }
            }
        }

        #endregion Tools

        #region Offsets

        [Route("offset/{offsetId:int}"), HttpPut]
        public IHttpActionResult UpdateOffset(short offsetId, OffsetModel offsetData)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                CmsError cmsError = ncAdapter.UpdateOffset(offsetId, offsetData);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                offsetData.Id = offsetId;

                return Ok(offsetData); 
            }
        }

        [Route("tool/{toolId:int}/position/{positionId:int}/offset/{offsetId:int}"), HttpPut]
        public IHttpActionResult UpdateToolOffset(int toolId, int positionId, short offsetId)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                CmsError cmsError = ncAdapter.UpdateToolOffsetId(toolId, positionId, offsetId, out DTONcToolModel tool);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(tool);
            }
        }

        #endregion Offsets

        #region Shanks

        [Route("shanks"), HttpGet]
        public IHttpActionResult GetShanks()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                return Ok(toolsManager.GetShanksWithSpace());
            }
        }

        [Route("shank/{shankId:int}"), HttpPost]
        public IHttpActionResult AddShank(short shankId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if exists a tool with the same id
                DbNcShankModel dbShank = toolsManager.FindShank(shankId);
                if (dbShank != null)
                    return BadRequest(API_ERROR_KEYS.ID_ALREADY_EXIST);
            }

            if (!ToolManagerConfig.ShankOpt)
                return BadRequest(API_ERROR_KEYS.OPTION_NOT_ACTIVE);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                DTONewNcShankModel dtoShank = new DTONewNcShankModel()
                {
                    Balluf = 0,
                    MagazinePositionType = 0
                };
                DTONcShankModel shank = (DTONcShankModel)toolsManager.AddShank(dtoShank, shankId);

                return Ok(shank);
            }
        }

        [Route("shank/{shankId:int}"), HttpPut]
        public IHttpActionResult PutShank(int shankId, [FromBody][Required]DTONewNcShankModel dtoShank)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return NotFound();

                // Check if tools are mounted in spindle
                foreach (var tool in shank.Tools)
                {
                    if (ToolIsInSpindle(tool.ToolId))
                        return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
                }

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    CmsError cmsError = ncAdapter.Connect();
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    // Update shank
                    cmsError = ncAdapter.UpdateShank(shankId, dtoShank, out DTONcShankModel newShank);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newShank);
                }
            }
        }

        [Route("shank/{shankId:int}"), HttpDelete]
        public IHttpActionResult DeleteShank(int shankId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return NotFound();

                // Check if tools are mounted in spindle
                foreach (var tool in shank.Tools)
                {
                    if (ToolIsInSpindle(tool.ToolId))
                        return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
                }

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    CmsError cmsError = ncAdapter.Connect();
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    cmsError = ncAdapter.DeleteNcShank(shank.ShankId);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok();
                }
            }
        }

        #endregion Shanks

        #region Families

        [Route("families"), HttpGet]
        public IHttpActionResult GetFamilies()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DTONcFamilyModel> families = toolsManager.GetFamilies();

                return Ok(families);
            }
        }

        [Route("family/{familyId:int}"), HttpPost]
        public IHttpActionResult AddFamily(short familyId)
        {
            // Create default family
            DTONcFamilyModel defaultFamily = new DTONcFamilyModel();
            // Copy data from static obj configured
            SupportFunctions.CopyProperties(DTO_TOOL_WITH_FAM, defaultFamily);
            defaultFamily.Id = familyId;

            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                DTONcFamilyModel newFamily = ncAdapter.AddFamily(defaultFamily);

                return Ok(newFamily);
            }
        }

        [Route("family/{familyId:int}"), HttpPut]
        public IHttpActionResult PutFamily(int familyId, [FromBody][Required]DTONewNcFamilyModel dtoFamily)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if family exists
                DbNcFamilyModel family = toolsManager.FindFamily(familyId);
                if (family == null)
                    return NotFound();

                // Check if tools are mounted in spindle
                foreach (var tool in family.Tools)
                {
                    if (ToolIsInSpindle(tool.ToolId))
                        return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
                }

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    CmsError cmsError = ncAdapter.Connect();
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    // Update into db and NC
                    cmsError = ncAdapter.UpdateFamily(familyId, dtoFamily, out DTONcFamilyModel newFamily);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newFamily);
                }
            }
        }

        [Route("family/{familyId:int}"), HttpDelete]
        public IHttpActionResult DeleteFamily(int familyId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Find if exists
                DbNcFamilyModel family = toolsManager.FindFamily(familyId);
                if (family == null)
                    return NotFound();

                // Check if tools are mounted in spindle
                foreach (var tool in family.Tools)
                {
                    // 
                    var t = toolsManager.FindToolWithDependencies(tool.ToolId);
                    if(t.Shank != null && t.Shank.MagazineId != null && t.Shank.PositionId != null)
                        return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                    //if (ToolIsInSpindle(tool.ToolId))
                    //    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
                }

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                { 
                    CmsError cmsError = ncAdapter.Connect();
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    //Delete
                    cmsError = ncAdapter.DeleteNcFamily(familyId);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok();
                }
            }
        }

        #endregion Families

        #region Magazine positions

        [Route("magazines_positions"), HttpGet]
        public IHttpActionResult GetMagazinesPositions()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DbNcMagazinePositionModel> magazines = toolsManager.FindMagazinesPositions();

                return Ok(magazines);
            }
        }

        [Route("magazine/{magazineId:int}/positions"), HttpGet]
        public IHttpActionResult GetMagazinesPositions(byte magazineId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DTONcMagazinePositionModel> magazine = toolsManager.GetMagazinePositions(magazineId);

                return Ok(magazine);
            }
        }

        [Route("magazine/{magazineId}/position/{positionId}"), HttpPut]
        public IHttpActionResult PutMagazinePosition([Required]byte magazineId, [Required]ushort positionId, [FromBody]DTONcMagazinePositionModel dtoPos)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if magazine&position exists
                DbNcMagazinePositionModel pos = toolsManager.FindMagazinePosition(magazineId, positionId);
                if (pos == null)
                    return NotFound();

                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    ncAdapter.Connect();
                    CmsError cmsError = ncAdapter.UpdateMagazinePosition(pos, dtoPos, out DTONcMagazinePositionModel newPos);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newPos);
                }
            }
        }

        #endregion Magazine positions


        [Route("magazine/{magazineId:int}/mounted_shanks"), HttpGet]
        public IHttpActionResult GetMagazineTools(byte magazineId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if magazine exists
                List<DbNcMagazinePositionModel> pos = toolsManager.FindMagazinePositions(magazineId);
                if (pos.Count <= 0)
                    return NotFound();

                List<DTONcShankModel> mountedShank = toolsManager.GetMountedShanks(magazineId);

                return Ok(mountedShank);
            }
        }

        [Route("magazine/available_shanks"), HttpGet]
        public IHttpActionResult GetAvailableShanks()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DTONcShankModel> shanks = new List<DTONcShankModel>();

                shanks = toolsManager.GetAvailableShanksWithChilds();

                return Ok(shanks);
            }
        }

        [Route("magazine/available_tools"), HttpGet]
        public IHttpActionResult GetAvailableTools()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DTONcToolModel> tools = toolsManager.GetAvailableTools();

                return Ok(tools);
            }
        }

        [Route("magazine/{magazineId:int}/load/position/{positionId:int}"), HttpPut]
        public IHttpActionResult LoadToolInToMagazine(byte magazineId, ushort positionId, [FromBody][Required] DTONcUpdateMagazineModel shankId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);
            if (shankId.ShankId == 0)
                return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

            DTONcShankModel dtoShank = new DTONcShankModel();

            // Check data
            DbNcShankModel shank;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                shank = toolsManager.FindShankWithTools(shankId.ShankId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // Check if shank is already loaded somewhere
                if (shank.MagazineId != null)
                    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                // Check if magazine position exists
                DbNcMagazinePositionModel magPos = toolsManager.FindMagazinePosition(magazineId, positionId);
                if (magPos == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                // Check position type
                //if (shank.Tools.FirstOrDefault().Family.ToolType != magPos.Type)
                //    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                
                // Check if the mag pos is disabled
                if (magPos.Disabled == true)
                    return BadRequest(API_ERROR_KEYS.MAG_POS_DISABLED);
                
                using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
                {
                    // Get Configuration
                    ncAdapter.Connect();

                    // Check if shank can fit
                    CmsError cmsError = ncAdapter.CheckIfShankCanFit(
                        magazineId,
                        positionId,
                        shank // mounted tools
                        );

                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    dtoShank = toolsManager.GetShank(shank.ShankId);
                }

                // Update shank data
                DTONcMagazinePositionModel magazinePos = (DTONcMagazinePositionModel)toolsManager.LoadShankInMagazine(magazineId, positionId, shank);
                // Set shankId
                magazinePos.ShankId = shank.ShankId;

                dtoShank.MagazineId = magazineId;
                dtoShank.PositionId = positionId;
                dtoShank.OriginMagazineId = magazineId;
                dtoShank.OriginPositionId = positionId;

                return Ok(dtoShank);
            }
        }

        [Route("magazine/{magazineId:int}/unload/position/{positionId:int}"), HttpPut]
        public IHttpActionResult UnloadToolInToMagazine(byte magazineId, ushort positionId, [FromBody][Required] DTONcUpdateMagazineModel shankId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);
            if (shankId.ShankId == 0)
                return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

            // Check data
            DbNcShankModel shank;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                shank = toolsManager.FindShankWithTools(shankId.ShankId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // Check if tools are mounted in spindle
                foreach (var tool in shank.Tools)
                {
                    if (ToolIsInSpindle(tool.ToolId))
                        return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
                }

                // Check if magazine position exists
                DbNcMagazinePositionModel magPos = toolsManager.FindMagazinePosition(magazineId, positionId);
                if (magPos == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                //// Check if the mag pos is disabled
                //if (magPos.Disabled == true)
                //    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // Check if magazine position is not occupied
                DbNcShankModel shankMounted = toolsManager.FindShanksByPositions(magazineId, positionId);
                if (shankMounted == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                DTONcMagazinePositionModel magazinePos = (DTONcMagazinePositionModel)toolsManager.UnloadShankInMagazine(magazineId, positionId, shank);

                return Ok(magazinePos);
            }
        }

        [Route("shank/{shankId:int}/load/tool/{toolId:int}"), HttpPut]
        public IHttpActionResult LoadToolIntoShank(short shankId, int toolId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            DbNcToolModel tool;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
            }

            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                DTONcShankModel shank = ncAdapter.LoadIntoShank(tool, shankId);

                return Ok(shank);
            }
        }

        [Route("shank/{shankId:int}/unload/tool/{toolId:int}"), HttpPut]
        public IHttpActionResult UnloadToolIntoShank(int shankId, int toolId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            DbNcToolModel tool;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            { 
                // Check if shank exists 
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
            }

            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                DTONcShankModel shank = ncAdapter.UnloadFromShank(tool);

                return Ok(shank);
            }
        }

        [Route("start_edit_tooling/{magazineId:int}"), HttpPut]
        public IHttpActionResult StartEditTooling(int magazineId)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();
                 
                CmsError cmsError = ncAdapter.StartEditTooling(magazineId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok();
            }
        }

        [Route("stop_edit_tooling/{magazineId:int}"), HttpPut]
        public IHttpActionResult StopEditTooling(int magazineId)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                Stopwatch st = new Stopwatch();
                st.Restart();
                CmsError cmsError = ncAdapter.StopEditTooling(magazineId);
                Console.WriteLine("TOOL TABLE WRITE TIME " + st.ElapsedMilliseconds);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok();
            }
        }

        [Route("assisted_tooling/"), HttpPost]
        public IHttpActionResult StartAssistedTooling(DTOAssistedToolingModel data)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                ncAdapter.Connect();

                using (NcToolManagerController toolsManager = new NcToolManagerController())
                {
                    var tool = toolsManager.FindTool(data.ToolId);
                    if (tool == null)
                        return BadRequest();

                    CmsError cmsError = ncAdapter.StartAssistedToolingProcedure(data.ToolId, (ushort)tool.FamilyId, (ushort)tool.ShankId, data.MagazineId, data.PositionId, data.Action);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);
                }

                return Ok();
            }
        }

        [Route("export"), HttpPost]
        public IHttpActionResult ExportToolTable()
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                DTOExportToolTableModel expData = toolsManager.GetExportData();

                return Ok(expData);
            }
        }

        [Route("import"), HttpPost]
        public async Task<IHttpActionResult> ImportToolTable()
        {
            // Check whether the POST operation is MultiPart?
            if (!Request.Content.IsMimeMultipartContent())
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);

            var filesReadToProvider = await Request.Content.ReadAsMultipartAsync();

            var stream = filesReadToProvider.Contents.FirstOrDefault();
            if (stream == null)
                return BadRequest();

            var fileBytes = await stream.ReadAsByteArrayAsync();

            // Convert bytes into json string
            string jsonString = Encoding.UTF8.GetString(fileBytes);

            bool val = IsValidJson(jsonString, out DTOExportToolTableModel importData);
            if (!val)
                return BadRequest(API_ERROR_KEYS.IMPORT_FILE_NOT_VALID);

            if(importData.Families == null || importData.Shanks == null || importData.Tools == null)
                return BadRequest(API_ERROR_KEYS.IMPORT_FILE_NOT_VALID);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Import data in the database
                List <DTOImportStatusModel> importStatus = toolsManager.ImportData(importData);

                return Ok(importStatus);
            }
        }

        [Route("selfadaptivepathstep"), HttpGet]
        public IHttpActionResult GetSelfAdaptivePathStep()
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                DTOSelfAdaptiveModel sam;

                CmsError cmsError = ncAdapter.Connect();
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                cmsError = ncAdapter.GetSelfAdaptiveStep(out sam);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(sam);
            }
        }

        [Route("selfadaptivepathstep"), HttpPut]
        public IHttpActionResult SetSelfAdaptivePathStep([FromBody][Required]DTOSelfAdaptiveModel dtoSelfAdaptiveModel)
        {
            using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
            {
                CmsError cmsError = ncAdapter.Connect();
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                cmsError = ncAdapter.SetSelfAdaptiveStep(dtoSelfAdaptiveModel);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok();
            }
        }
        #region Private Functions

        private static DTONcToolWithFamilyModel DTO_TOOL_WITH_FAM = new DTONcToolWithFamilyModel()
        {
            Id = 0,
            Name = DEFAULT_FAM_NAME,
            OffsetId1 = null,
            OffsetId2 = null,
            OffsetId3 = null,
            LeftSize = 1,
            RightSize = 1
        };

        private bool IsValidJson(string jsonString, out DTOExportToolTableModel data)
        {
            data = new DTOExportToolTableModel();
            if (string.IsNullOrWhiteSpace(jsonString))
                return false;
           
            try
            {
                // Deserialize the string into DTO object
                data = JsonConvert.DeserializeObject<DTOExportToolTableModel>(jsonString);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONewNcToolWithFamilyModel familyData)
        {
            DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
            // Copy family fields
            SupportFunctions.CopyProperties(familyData, familyTool);
            // Copy tool fields
            SupportFunctions.CopyProperties(tool, familyTool);

            return familyTool;
        }

        private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONcToolWithFamilyModel familyData)
        {
            DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
            // Copy family fields
            SupportFunctions.CopyProperties(familyData, familyTool);
            // Copy tool fields
            SupportFunctions.CopyProperties(tool, familyTool);

            return familyTool;
        }

        private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONcFamilyModel familyData)
        {
            DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
            // Copy family fields
            SupportFunctions.CopyProperties(familyData, familyTool);
            // Copy tool fields
            SupportFunctions.CopyProperties(tool, familyTool);

            return familyTool;
        }

        private bool ToolIsInSpindle(int toolId)
        {
            foreach (var head in LastHeadsData.ToList())
            {
                if (head is DTOSpindleModel)
                {
                    var spindle = head as DTOSpindleModel;
                    if (!spindle.FixedHead && spindle.MountedTool == toolId)
                        return true;
                }
            }

            return false;
        }

        #endregion
    }

    //[Route("tool_old"), HttpPost]
    //public IHttpActionResult AddTool([FromBody][Required]DTONewNcToolWithFamilyModel dtoToolWithFamily)
    //{
    //    if (!ModelState.IsValid)
    //        return BadRequest(ModelState);

    //    short familyId = 0;
    //    using (NcToolManagerController toolsManager = new NcToolManagerController())
    //    {
    //        // Check if option is active
    //        if (ToolManagerConfig.FamilyOpt)
    //        {
    //            if (dtoToolWithFamily.FamilyId == 0)
    //            {
    //                // If param equal to 0 create a new family
    //                DTONcFamilyModel newFamily = new DTONcFamilyModel() { Name = "NewFamily", LeftSize = 1, RightSize = 1 };
    //                // Add new family & update family id
    //                DbNcFamilyModel newFam = toolsManager.AddFamily(newFamily);
    //                dtoToolWithFamily.FamilyId = newFam.FamilyId;
    //                dtoToolWithFamily.Name = newFam.Name;
    //            }
    //            else
    //            {
    //                // Check if family exists
    //                DbNcFamilyModel fam = toolsManager.FindFamily(dtoToolWithFamily.FamilyId);
    //                if (fam == null)
    //                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

    //                // Update return data
    //                if (ToolManagerConfig.FamilyOpt)
    //                {
    //                    dtoToolWithFamily.Name = fam.Name;
    //                }
    //            }
    //        }
    //        else
    //        {
    //            // Copy only family data from tool&fam model
    //            DTONcFamilyModel newFamily = new DTONcFamilyModel();
    //            SupportFunctions.CopyProperties(dtoToolWithFamily, newFamily);

    //            // Add new family
    //            DbNcFamilyModel dbFam = toolsManager.AddFamily(newFamily);
    //            if (dbFam == null)
    //                return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
    //            dtoToolWithFamily.FamilyId = dbFam.FamilyId;

    //            // Set common id
    //            familyId = dbFam.FamilyId;
    //        }

    //        // Check if  option is active
    //        if (!ToolManagerConfig.ShankOpt)
    //        {
    //            // If option is not active create a shank
    //            DTONewNcShankModel newShank = new DTONewNcShankModel()
    //            {
    //                Balluf = 0,
    //                MagazinePositionType = 0
    //            };

    //            // Create a new shank
    //            DbNcShankModel ncShank = toolsManager.AddShank(newShank, familyId);
    //            // Connect tool to new shank
    //            dtoToolWithFamily.ShankId = ncShank.ShankId;
    //        }
    //        else
    //            dtoToolWithFamily.ShankId = null;
    //    }

    //    using (ncAdapter ncAdapter = new ncAdapter())
    //    {
    //        ncAdapter.Connect();

    //        // Add tool
    //        CmsError cmsError = ncAdapter.AddTool(dtoToolWithFamily, out DTONcToolModel newTool, familyId);
    //        if (cmsError.IsError())
    //            return BadRequest(cmsError.localizationKey);

    //        return Ok(CreateToolAndFamilyObj(newTool, dtoToolWithFamily));
    //    }
    //}

}