using LiteDB;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.ExtensionMethods;
using Tango.Core.Helpers;
using Tango.CSV;

namespace Tango.BL.Entities
{
    public partial class ProcessParametersTable : ProcessParametersTableBase
    {
        public event EventHandler DyeingSpeedMinInkUptakeChanged;
        private static List<ProcessParameterCsvModel> _csvModels;

        [NotMapped]
        [JsonIgnore]
        public static MachineTypes DryerBufferMode { get; set; }

        public const double DRYER_METERS_PER_CYCLE = 0.76;
        public const double DRYER_TO_SPOOL_LENGTH_METERS = 0.9;

        protected override void RaisePropertyChanged(string propName)
        {
            base.RaisePropertyChanged(propName);

            if (propName == nameof(DyeingSpeed) || propName == nameof(MinInkUptake))
            {
                OnDyeingSpeedMinInkUptakeChanged();
            }
        }

        protected virtual void OnDyeingSpeedMinInkUptakeChanged()
        {
            DyeingSpeedMinInkUptakeChanged?.Invoke(this, new EventArgs());
        }

        [NotMapped]
        [JsonIgnore]
        public double DryerBufferLengthMeters
        {
            get
            {
                if (DryerBufferMode == MachineTypes.TS1800)
                {
                    return (DryerBufferLength * DRYER_METERS_PER_CYCLE) + DRYER_TO_SPOOL_LENGTH_METERS;
                }
                else
                {
                    return DryerBufferLength;
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProcessParametersTable" /> class.
        /// </summary>
        public ProcessParametersTable() : base()
        {

        }

        public double GetAverageTemperature()
        {
            List<double> heaters = new List<double>();

            heaters.Add(HeadZone1Temp);
            heaters.Add(HeadZone2Temp);
            heaters.Add(HeadZone3Temp);
            heaters.Add(HeadZone4Temp);
            heaters.Add(HeadZone5Temp);
            heaters.Add(HeadZone6Temp);
            heaters.Add(HeadZone7Temp);
            heaters.Add(HeadZone8Temp);
            heaters.Add(HeadZone9Temp);
            heaters.Add(HeadZone10Temp);
            heaters.Add(HeadZone11Temp);
            heaters.Add(HeadZone12Temp);
            heaters.Add(LBlowerTemp);
            heaters.Add(RBlowerTemp);

            return heaters.Average();
        }

        public PMR.Printing.ProcessParameters ToProcessParametersPMR()
        {
            PMR.Printing.ProcessParameters p = new PMR.Printing.ProcessParameters();
            this.MapPrimitivesTo(p);
            return p;
        }

        #region Visual Representation

        public class ProcessParameterCsvModel
        {
            public String Name { get; set; }
            public String Description { get; set; }
            public List<MachineTypes> MachineTypes { get; set; }
            public String Group { get; set; }
            public int Index { get; set; }
            public String StringFormat { get; set; }

            public ProcessParameterCsvModel()
            {
                MachineTypes = new List<MachineTypes>();
            }
        }

        public class ProcessParameter : ExtendedObject
        {
            private ParameterItem _parameterItem;
            private ProcessParametersTable _table;

            public String Name { get; set; }
            public List<MachineTypes> MachineTypes { get; set; }
            public String Group { get; set; }
            public int Index { get; set; }
            public String StringFormat { get; set; }

            public bool HasDiff
            {
                get
                {
                    if (_table == null) return false;
                    if (_table.ProcessParametersTablesGroup == null) return false;

                    foreach (var otherTable in _table.ProcessParametersTablesGroup.ProcessParametersTables.Where(x => x != _table).ToList())
                    {
                        var otherValue = otherTable.VisualParameters.FirstOrDefault(x => x.Name == Name);
                        if (otherValue != null)
                        {
                            if (otherValue.Value != Value) return true;
                        }
                    }

                    return false;
                }
            }

            public double Value
            {
                get { return (double)_parameterItem.Value; }
                set
                {
                    _parameterItem.Value = value;
                    RaisePropertyChangedAuto();
                    RaisePropertyChanged(nameof(HasDiff));

                    if (_table == null) return;
                    if (_table.ProcessParametersTablesGroup == null) return;

                    foreach (var otherTable in _table.ProcessParametersTablesGroup.ProcessParametersTables.Where(x => x != _table).ToList())
                    {
                        var otherValue = otherTable.VisualParameters.FirstOrDefault(x => x.Name == Name);
                        if (otherValue != null)
                        {
                            otherValue.Invalidate();
                        }
                    }
                }
            }

            public ProcessParameter(ParameterItem parameterItem, ProcessParametersTable table)
            {
                MachineTypes = new List<MachineTypes>();
                _parameterItem = parameterItem;
                _table = table;
            }

            public void Invalidate()
            {
                RaisePropertyChanged(nameof(HasDiff));
            }
        }

        public class ProcessParameterGroup
        {
            public String Name { get; set; }

            public List<ProcessParameter> Parameters { get; set; }

            public ProcessParameterGroup()
            {
                Parameters = new List<ProcessParameter>();
            }
        }

        [NotMapped]
        [XmlIgnore]
        [BsonIgnore]
        [JsonIgnore]
        [ParameterIgnore]
        public List<ProcessParameterGroup> ParametersGroups
        {
            get
            {
                List<ProcessParameterGroup> groups = new List<ProcessParameterGroup>();

                foreach (var g in VisualParameters.GroupBy(x => x.Group))
                {
                    ProcessParameterGroup group = new ProcessParameterGroup();
                    group.Name = g.First().Group;
                    group.Parameters.AddRange(g);
                    groups.Add(group);
                }

                return groups;
            }
        }

        private List<ProcessParameter> _visualParameters;
        [NotMapped]
        [XmlIgnore]
        [BsonIgnore]
        [JsonIgnore]
        [ParameterIgnore]
        public List<ProcessParameter> VisualParameters
        {
            get
            {
                if (_visualParameters != null)
                {
                    return _visualParameters;
                }

                if (_csvModels == null)
                {
                    var csv = EmbeddedResourceHelper.GetEmbeddedResourceText("Tango.BL.ProcessParameters.csv");
                    CsvDynamicReader reader = CsvDynamicReader.FromString(csv);

                    _csvModels = new List<ProcessParameterCsvModel>();

                    foreach (var row in reader.Rows)
                    {
                        ProcessParameterCsvModel csvModel = new ProcessParameterCsvModel();

                        csvModel.Name = row.Read("Name", "N/A");
                        csvModel.Description = row.Read("Description", "N/A");
                        csvModel.Group = row.Read("Group", "N/A");
                        csvModel.Index = row.Read("Index", 0);
                        csvModel.StringFormat = row.Read("StringFormat", "0.0");

                        String machineType = row.Read("MachineType", "ALL");

                        switch (machineType)
                        {
                            case "ALL":
                                csvModel.MachineTypes.AddRange(Enum.GetValues(typeof(MachineTypes)).Cast<MachineTypes>());
                                break;
                            case "TS-1800":
                                csvModel.MachineTypes.Add(MachineTypes.TS1800);
                                break;
                            case "X1":
                                csvModel.MachineTypes.Add(MachineTypes.X1);
                                break;
                            case "X4":
                                csvModel.MachineTypes.Add(MachineTypes.Eureka);
                                break;
                            case "X":
                                csvModel.MachineTypes.Add(MachineTypes.X1);
                                csvModel.MachineTypes.Add(MachineTypes.Eureka);
                                break;
                        }

                        _csvModels.Add(csvModel);
                    }
                }

                var parameters = this.Parameters.Where(x => x.Type == typeof(Double)).ToList();

                _visualParameters = new List<ProcessParameter>();

                foreach (var p in parameters)
                {
                    var csvModel = _csvModels.SingleOrDefault(x => x.Name.Replace("_", "").ToLower() == p.Name.Replace(" ", "").ToLower());

                    if (csvModel.MachineTypes.Count > 0)
                    {
                        ProcessParameter parameter = new ProcessParameter(p, this);
                        parameter.Name = csvModel.Description;
                        parameter.MachineTypes = csvModel.MachineTypes;
                        parameter.Group = csvModel.Group;
                        parameter.Index = csvModel.Index;
                        parameter.StringFormat = csvModel.StringFormat;

                        _visualParameters.Add(parameter);
                    }
                }

                _visualParameters = _visualParameters.OrderBy(x => x.Index).ToList();

                _visualParameters.ForEach(x => x.Invalidate());

                return _visualParameters;
            }
        }

        #endregion
    }
}