using Newtonsoft.Json;
using Step.Model.DTOModels.JobModels;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using static CMS_CORE_Library.Models.DataStructures;
using static Step.Model.Constants;

namespace Step.Utils
{
    public static class SupportFunctions
    {
        public static SOFTKEY_TYPE GetSoftKeyType(string type)
        {
            switch (type)
            {
                case "softKey_procedure": return SOFTKEY_TYPE.PROCEDURE;
                case "softKey_group": return SOFTKEY_TYPE.GROUP;
                default: return SOFTKEY_TYPE.TOGGLE;
            }
        }

        public static HEAD_TYPE GetHeadType(string type)
        {
            switch (type)
            {
                case "SPINDLE": return HEAD_TYPE.SPINDLE;
                case "AWJ": return HEAD_TYPE.AWJ;
                default: return HEAD_TYPE.WJ;
            }
        }

        public static int GetPlcIdFromNcSoftKey(string softKey)
        {
            switch (softKey)
            {
                case "auto": return 1;
                case "edit": return 2;
                case "mdi": return 3;
                case "dnc": return 4;
                case "ref": return 5;
                case "jog": return 6;
                case "jogInc": return 7;
                case "restart": return 8;
                case "teach": return 9;
                case "retract": return 10;
                case "wcsMcs": return 11;
                case "handle": return 12;
                case "reset": return 13;
                case "blk": return 14;
                case "blkDel": return 15;
                case "opStop": return 16;
                case "dryRun": return 17;
                case "prgTest": return 18;
                case "manualHandleInterrupt": return 19;
                case "teachIn": return 20;
                case "incPlane": return 21;
                case "plus": return 22;
                case "minus": return 23;
                case "rapid": return 24;
                case "xOne": return 25;
                case "xTen": return 26;
                case "xHundred": return 27;
                case "xThousand": return 28;
                default: return -1;
            }
        }

        public static double ConvertInMinutes(double number, MAINTENANCE_UNIT_OF_MEASURE unit)
        {
            switch (unit)
            {
                case MAINTENANCE_UNIT_OF_MEASURE.mm:
                    return number;

                case MAINTENANCE_UNIT_OF_MEASURE.H:
                    return number * 60;

                case MAINTENANCE_UNIT_OF_MEASURE.D:
                    return number * (24 * 60);

                case MAINTENANCE_UNIT_OF_MEASURE.M:
                    return (30 * number) * (24 * 60);

                default:
                    return number;
            }
        }

        public static void CopyProperties<TParent, TChild>(TParent parent, TChild child) where TParent : class where TChild : class
        {
            var parentProperties = parent.GetType().GetProperties();
            var childProperties = child.GetType().GetProperties();

            foreach (var parentProperty in parentProperties)
            {
                foreach (var childProperty in childProperties)
                {
                    if (parentProperty.Name == childProperty.Name && parentProperty.PropertyType == childProperty.PropertyType)
                    {
                        childProperty.SetValue(child, parentProperty.GetValue(parent));
                        break;
                    }
                }
            }
        }

        public static int GetNextId(IEnumerable<int> objIds)
        {
            if (objIds.Count() == 0)
                return 1;

            return objIds.Max() + 1;
        }

        public static short GetFirstFreeId(IEnumerable<short> objIds)
        {
            if (objIds.Count() == 0)
                return 1;

            List<short> listOfPossibleIds = Enumerable.Range(1, objIds.Max() + 1).Select(x => (short)x).ToList();

            IEnumerable<short> res = listOfPossibleIds.Except(objIds).ToList();

            if (res.Count() > 0)
                return res.First();
            else
                return 1;
        }

        public static string FindImageBase64String(string directoryPath, string imageName)
        {
            string fileName = Path.GetFileNameWithoutExtension(imageName);
            foreach (string ext in VALID_IMAGE_EXTENSIONS)
            {
                if (File.Exists(directoryPath + "\\" + fileName + ext))
                {
                    // Convert image to a base 64 string
                    return "data:image/" + ext + ";base64," + Convert.ToBase64String(File.ReadAllBytes(directoryPath + "\\" + fileName + ext));
                }
            }

            return "";
        }

        public static DTOJobModel UnpackJobAndReadMetadata(string filePath, int processId)
        {
            DTOJobModel job = new DTOJobModel();
            string jobFolderPath = JOB_TMP_DIRECTORY + "\\" + processId + "\\";
            if (!Directory.Exists(jobFolderPath))
                Directory.CreateDirectory(jobFolderPath);

            // Check if job exists
            if (!File.Exists(filePath))
                return null;

            EmptyFolder(jobFolderPath);
            
            using (ZipArchive zipExtractor = ZipFile.OpenRead(filePath))
            {
                // Setup main job fields
                job.Name = Path.GetFileName(filePath);
                job.LastEditTimestamp = new FileInfo(filePath).LastAccessTime;

                foreach (ZipArchiveEntry entry in zipExtractor.Entries)
                {
                    // Extract file
                    entry.ExtractToFile(jobFolderPath + entry.Name, true);

                    // Get main program content
                    if (entry.Name.Equals(JOB_MAIN_FILENAME, StringComparison.OrdinalIgnoreCase))
                    {
                        using (var reader = new StreamReader(entry.Open()))
                            job.IsoMainProgram = (reader.ReadToEnd());
                    }
                    // Read images
                    else if (VALID_IMAGE_EXTENSIONS.Contains(Path.GetExtension(entry.Name).ToLower()))
                    {
                        var bytes = default(byte[]);
                        // Populate metadata
                        using (var memstream = new MemoryStream())
                        {
                            entry.Open().CopyTo(memstream);
                            bytes = memstream.ToArray();
                            job.Metadata.Generics.Images.Add(new DTOImageParamModel()
                            {
                                Name = Path.GetFileNameWithoutExtension(entry.Name),
                                Base64 = "data:image/" + Path.GetExtension(entry.Name).ToLower().TrimStart('.') + ";base64," + Convert.ToBase64String(bytes)
                            });
                        }
                    }
                    // Read metadata
                    else if (entry.Name.Equals(JOB_METADATA_FILENAME, StringComparison.OrdinalIgnoreCase))
                    {
                        DTOMetadataFieldsModel metasFromFile = new DTOMetadataFieldsModel();

                        using (var reader = new StreamReader(entry.Open()))
                        {
                            metasFromFile = JsonConvert.DeserializeObject<DTOMetadataFieldsModel>(reader.ReadToEnd());
                            if (metasFromFile == null)
                            {
                                return null;
                            }
                            else
                            {
                                job.Metadata.Generics.Description = metasFromFile.Description;
                                job.Metadata.Generics.ExecutionTime = metasFromFile.ExecutionTime;
                                job.Metadata.Tools = metasFromFile.Tools;
                                job.Metadata.Customs = metasFromFile.Customs;
                            }
                        }
                    }
                    // Consider other file as part program
                    else
                    {
                        job.PartPrograms.Add(jobFolderPath + entry.Name);
                    }
                }

                return job;
            }
        }

        public static void EmptyFolder(string path)
        {
            DirectoryInfo di = new DirectoryInfo(path);
            foreach (FileInfo file in di.GetFiles())
                file.Delete();
            foreach (DirectoryInfo dir in di.GetDirectories())
                dir.Delete(true);
        }

        public static bool IsValidJob(string filePath)
        {
            if (!File.Exists(filePath))
                return false;

            try
            {
                using (var archive = ZipFile.OpenRead(filePath))
                {
                    // Find key files
                    List<ZipArchiveEntry> files = archive
                        .Entries
                        .Where(x => x.FullName == JOB_MAIN_FILENAME || x.FullName == JOB_METADATA_FILENAME)
                        .ToList();
                    // if there aren't both
                    if (files.Count() < 2)
                        return false;
                    else
                        return true;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }



        public static DTOJobModel ReadExtractedJobMetadata(int processId)
        {
            string filePath = JOB_TMP_DIRECTORY + "\\" + processId + "\\";
            if (!Directory.Exists(filePath))
                return null;
            
            // Setup main Fields
            DTOJobModel jobData = new DTOJobModel()
            {
                Name = Path.GetFileName(filePath),
                LastEditTimestamp = new FileInfo(filePath).LastAccessTime
            };

            DirectoryInfo di = new DirectoryInfo(filePath);
            foreach (FileInfo file in di.GetFiles())
            {
                // Get main program content
                if (file.Name.Equals(JOB_MAIN_FILENAME, StringComparison.OrdinalIgnoreCase))
                {
                    jobData.IsoMainProgram = (File.ReadAllText(file.FullName));
                }
                // Get images content without extract files
                else if (VALID_IMAGE_EXTENSIONS.Contains(Path.GetExtension(file.Name).ToLower()))
                {
                    byte[] bytes = File.ReadAllBytes(file.FullName);
                    jobData.Metadata.Generics.Images.Add(new DTOImageParamModel()
                    {
                        Name = file.Name,
                        Base64 = "data:image/" + Path.GetExtension(file.Name).ToLower().TrimStart('.') + ";base64," + Convert.ToBase64String(bytes)
                    });
                }
                // Metadata
                else if (file.Name.Equals(JOB_METADATA_FILENAME, StringComparison.OrdinalIgnoreCase))
                {
                    DTOMetadataFieldsModel metasFromFile = new DTOMetadataFieldsModel();

                    metasFromFile = JsonConvert
                        .DeserializeObject<DTOMetadataFieldsModel>
                            (File.ReadAllText(file.FullName));

                    if (metasFromFile == null)
                        return null;
                    else
                    {
                        jobData.Metadata.Generics.Description = metasFromFile.Description;
                        jobData.Metadata.Generics.ExecutionTime = metasFromFile.ExecutionTime;
                        jobData.Metadata.Tools = metasFromFile.Tools;
                        jobData.Metadata.Customs = metasFromFile.Customs;
                    }
                }
            }

            return jobData;
        }


        public static SCADA_MEM_TYPE GetMemTypeFromString(string memType)
        {
            memType = memType.ToUpper();
            switch (memType)
            {
                case "BOOL":
                    return SCADA_MEM_TYPE.BOOL;

                case "BYTE":
                    return SCADA_MEM_TYPE.BYTE;

                case "WORD":
                    return SCADA_MEM_TYPE.WORD;

                case "INT":
                    return SCADA_MEM_TYPE.INT;

                default:
                    return SCADA_MEM_TYPE.BOOL;
            }
        }
    }
}