path: root/Software/Visual_Studio/Tango.BL/Entities/Rml.cs

using ColorMine.ColorSpaces;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using Tango.BL.Builders;
using Tango.BL.Enumerations;
using Tango.BL.Serialization;

namespace Tango.BL.Entities
{
    public partial class Rml : RmlBase
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Rml" /> class.
        /// </summary>
        public Rml() : base()
        {
            WhitePointL = 92.1815;
            WhitePointA = 2.2555;
            WhitePointB = -10.9325;
            PliesPerThread = 1;
        }

        protected override void OnWhitePointLChanged(double whitepointl)
        {
            base.OnWhitePointLChanged(whitepointl);
            UpdateColor();
        }

        protected override void OnWhitePointAChanged(double whitepointa)
        {
            base.OnWhitePointAChanged(whitepointa);
            UpdateColor();
        }

        protected override void OnWhitePointBChanged(double whitepointb)
        {
            base.OnWhitePointBChanged(whitepointb);
            UpdateColor();
        }

        private void UpdateColor()
        {
            RaisePropertyChanged(nameof(Color));
        }

        [NotMapped]
        [JsonIgnore]
        public Color Color
        {
            get
            {
                Lab lab = new Lab(WhitePointA, WhitePointA, WhitePointB);
                Rgb rgb = lab.To<Rgb>();
                return Color.FromRgb((byte)rgb.R, (byte)rgb.G, (byte)rgb.B);
            }
        }

        /// <summary>
        /// Gets or sets the thread head type.
        /// </summary>
        [NotMapped]
        [JsonIgnore]
        public HeadTypes RmlHeadType
        {
            get
            {
                return (HeadTypes)HeadType;
            }
            set
            {
                HeadType = value.ToInt32();
            }
        }

        /// <summary>
        /// Gets or sets the thread qualification level.
        /// </summary>
        [NotMapped]
        [JsonIgnore]
        public RmlQualifications RmlQualificationLevel
        {
            get
            {
                return (RmlQualifications)QualificationLevel;
            }
            set
            {
                QualificationLevel = value.ToInt32();
            }
        }

        [NotMapped]
        [JsonIgnore]
        public String FinalName
        {
            get
            {
                return String.IsNullOrWhiteSpace(DisplayName) ? Name : DisplayName;
            }
        }

        protected override void OnNameChanged(string name)
        {
            base.OnNameChanged(name);
            RaisePropertyChanged(nameof(FinalName));
        }

        protected override void OnDisplayNameChanged(string displayname)
        {
            base.OnDisplayNameChanged(displayname);
            RaisePropertyChanged(nameof(FinalName));
        }

        public ProcessParametersTablesGroup GetActiveProcessGroup()
        {
            return ProcessParametersTablesGroups.FirstOrDefault(x => x.Active);
        }

        public Task<String> ToRmlFile(ObservablesContext context)
        {
            return Task.Factory.StartNew<String>(() =>
            {
                var rml = new RmlBuilder(context).Set(Guid).WithActiveParametersGroup().WithCCT().WithLiquidFactors().WithSpools().WithRMLExtensions().Build();

                String result = rml.ToJson(new EntitySerializationStrategy()
                    .Include(() => rml.Cct)
                    .Include(() => rml.Gbd)
                    .Include(() => rml.Lub)
                    .Include(() => rml.LiquidTypesRmls)
                    .Include(() => rml.ProcessParametersTablesGroups)
                    .Include(() => rml.RmlsSpools)
                    .Include(() => rml.RmlsExtensions)
                    .Include(typeof(ProcessParametersTablesGroup).GetProperty(nameof(ProcessParametersTablesGroup.ProcessParametersTables))),
                    EntitySerializationFlags.IgnoreCollections | EntitySerializationFlags.IgnoreReferenceTypes | EntitySerializationFlags.Indented);

                return result;
            });
        }

        public static Task<Rml> FromRmlFile(ObservablesContext context, String json)
        {
            return Task.Factory.StartNew<Rml>(() =>
            {
                Rml rml = Rml.FromJson(json, new EntitySerializationStrategy(), EntitySerializationFlags.Indented);

                if (context.Rmls.Any(x => x.Guid == rml.Guid || x.Name == rml.Name))
                {
                    throw new InvalidOperationException($"Thread {rml.Name} already exist.");
                }

                if (rml.Cct != null)
                {
                    if (context.Ccts.Any(x => x.Guid == rml.Cct.Guid))
                    {
                        rml.Cct = null;
                    }
                }

                if (rml.Gbd != null)
                {
                    if (context.Gbds.Any(x => x.Guid == rml.Gbd.Guid))
                    {
                        rml.Gbd = null;
                    }
                }

                if (rml.Lub != null)
                {
                    if (context.Lubs.Any(x => x.Guid == rml.Lub.Guid))
                    {
                        rml.Lub = null;
                    }
                }
                
                rml.LastUpdated = DateTime.UtcNow;
                rml.Code = context.Rmls.Max(x => x.Code) + 1;

                return rml;
            });
        }

        public async Task<int> GetRequiredBtsrSpoolTension(ObservablesContext db, SpoolType jobSpoolType = null)
        {
            int tension = 0;

            var spoolTypes = await db.SpoolTypes.ToListAsync();
            var spoolType = spoolTypes.FirstOrDefault(x => x.Type == SpoolTypes.StandardSpool);

            if (jobSpoolType != null)
            {
                spoolType = jobSpoolType;
            }

            tension = spoolType != null ? spoolType.BtsrSpoolTension : 0;

            var rml_spool = RmlsSpools.FirstOrDefault(x => x.SpoolType.Type == spoolType.Type);
            if (rml_spool != null && rml_spool.BtsrSpoolTension.HasValue)
            {
                tension = rml_spool.BtsrSpoolTension.Value;
            }

            return tension;
        }

        #region Dencity and Fiber Count

        /// <summary>
        /// Called when the LinearMassDensityUnit has changed.
        /// </summary>
        protected override void OnLinearMassDensityUnitChanged(LinearMassDensityUnit linearmassdensityunit)
        {
            base.OnLinearMassDensityUnitChanged(linearmassdensityunit);
            UpdateDencityCount();
            UpdateFiberCount();
        }

        protected override void OnFiberSizeChanged(double fibersize)
        {
            base.OnFiberSizeChanged(fibersize);
            UpdateDencityCount();
            UpdateFiberCount();
        }

        /// <summary>
        /// Called when the PliesPerFiber has changed.
        /// </summary>
        protected override void OnPliesPerFiberChanged(Int32 pliesperfiber)
        {
            base.OnPliesPerFiberChanged(pliesperfiber);
            UpdateFiberCount();
           
        }

        protected override void OnPliesPerThreadChanged(Int32 pliesperthread)
        {
            base.OnPliesPerThreadChanged(pliesperthread);
            UpdateDencityCount();
            UpdateFiberCount();
            RaisePropertyChanged(nameof(RMLPlies));
        }

        private void UpdateDencityCount()
        {
            RaisePropertyChanged(nameof(DencityCount));
        }

        private void UpdateFiberCount()
        {
            RaisePropertyChanged(nameof(FiberCount));
        }

        [NotMapped]
        [JsonIgnore]
        public int DencityCount
        {
            get
            {
                var count = 0;
                if (LinearMassDensityUnit == null || FiberSize==0)
                    return count;
                if (LinearMassDensityUnit.Name== "Tex")
                   count = Convert.ToInt32(FiberSize) * 9;
                if (LinearMassDensityUnit.Name == "DTEX")
                    count = (int)(Convert.ToInt32(FiberSize) * 0.9);
                if (LinearMassDensityUnit.Name == "Ne")
                    count = (int)(5315 / Convert.ToInt32(FiberSize));
                if (LinearMassDensityUnit.Name == "Nm")
                    count = (int)(9000 / Convert.ToInt32(FiberSize));
                if (LinearMassDensityUnit.Name == "Denier")
                    count = (int)FiberSize;

                return PliesPerThread == 0 ? count : count * PliesPerThread;
            }
        }


        [NotMapped]
        [JsonIgnore]
        public string FiberCount
        {
            get
            {
                if (DencityCount == 0)
                    return "";

                double number =( double)PliesPerFiber / DencityCount;
                if (number < 1.0 && number >= 0.3)
                    return "Micro";
                if (number < 2.4 && number >= 1.0)
                    return "Fine";
                if (number <= 7.0 && number >= 2.4)
                    return "Medium";
                if (number > 7.0)
                    return "Coarse";
                return "";
            }
        }

        [NotMapped]
        [JsonIgnore]
        public double GetGramPer1000mLength
        {

            get
            {
                
                //if (LinearMassDensityUnit.Name == "Tex")
                //    return FiberSize;
                //if (LinearMassDensityUnit.Name == "DTEX")
                //    return (FiberSize /10);
                //if (LinearMassDensityUnit.Name == "Ne")
                //    return (590.5 / FiberSize);
                //if (LinearMassDensityUnit.Name == "Nm")
                //    return (1000 / FiberSize);
                //if (LinearMassDensityUnit.Name == "Denier")
                //    return FiberSize/9;
                
                return DencityCount  == 0? (1/9 ): (DencityCount / 9);
            }
        }


        [NotMapped]
        [JsonIgnore]
        public Plies RMLPlies
        {
            get { return (Plies)PliesPerThread; }
            set
            {
                base.PliesPerThread = value.ToInt32();
                RaisePropertyChangedAuto();
                UpdateDencityCount();
                UpdateFiberCount();
            }
        }

        #endregion
    }
}