using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using Tango.BL.DTO;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.BL.FineTuning;
using Tango.ColorConversion;
using Tango.Core.Commands;
using Tango.PPC.Shared.Statistics;

namespace Tango.FSE.Statistics.Models
{
    public class StopModel : PresentationBrushStop
    {
        public int Index { get; set; }
        public JobRunDTO JobRun { get; set; }
        public PresentationJob Job { get; set; }
        public PresentationSegment Segment { get; set; }
        public int JobIndex { get; set; }
        public int SegmentIndex { get; set; }
        public String ThreadName { get; set; }
        public RelayCommand<StopModel> ShowFailedMessageCommand { get; set; }
        public RelayCommand<StopModel> ShowExtendedInfoCommand { get; set; }
        public RelayCommand<StopModel> CopyCommand { get; set; }
        public JobRunExtendedInfo ExtendedInfo { get; set; }
        public bool IsAdvancedMode { get; set; }
        public VectorFineTuningRunModel FineTuningModel { get; set; }
        public MachineTypes MachineType { get; set; }

        public bool IsFineTuning
        {
            get { return FineTuningModel != null; }
        }

        public bool IsManualFineTuning
        {
            get { return IsFineTuning && FineTuningModel.Type == FineTuningTypes.ManualFineTuning; }
        }

        public bool IsFineTuningApproved { get; set; }

        public bool IsFineTuningSelected { get; set; }

        public String Input
        {
            get
            {
                switch (ColorSpace)
                {
                    case ColorSpaces.RGB:
                        return $"{Red}, {Green}, {Blue}";
                    case ColorSpaces.LAB:
                        return $"{Math.Round(L, 2)}, {Math.Round(A, 2)}, {Math.Round(B, 2)}";
                    case ColorSpaces.Catalog:
                        return $"{Catalog} => {CatalogItem}";
                    case ColorSpaces.Volume:
                        return String.Join("\n", GetVolumeInputs().Where(x => x.Volume > 0).Select(x => x.LiquidType.Name + ": " + Math.Round(x.Volume, 2)));
                }

                return "Unspecified";
            }
        }

        public String OutputString
        {
            get
            {
                return String.Join("\n", Output.Where(x => x != null && x.Volume > 0).Select(x => x.LiquidType.Name + ": " + Math.Round(x.Volume, 2)));
            }
        }

        public List<PresentationLiquidVolume> InputVolumes
        {
            get
            {
                return GetVolumeInputs().Where(x => x.Volume > 0).ToList();
            }
        }

        public List<PresentationLiquidVolume> Output
        {
            get
            {
                var output = new List<PresentationLiquidVolume>();
                output.AddRange(LiquidVolumes.Where(x => x.Volume > 0).OrderBy(x => x.LiquidType.PreferredIndex));
                //output.Add(LiquidVolumes.FirstOrDefault(x => x.LiquidType.Type == LiquidTypes.Transparent));
                return output;
            }
        }

        public TimeSpan Duration
        {
            get
            {
                return JobRun.EndDate - JobRun.StartDate;
            }
        }

        public List<LiquidQuantityModel> LiquidQuantities
        {
            get
            {
                var quantities = new List<LiquidQuantityModel>();

                foreach (var liquidVolume in LiquidVolumes)
                {
                    LiquidQuantityModel model = new LiquidQuantityModel();
                    model.LiquidType = liquidVolume.LiquidType;
                    model.Quantity = (double)typeof(JobRun).GetProperty(model.LiquidType.Name.Replace(" ", "") + "Quantity").GetValue(JobRun);
                    quantities.Add(model);
                }

                return quantities;
            }
        }

        public Color BestMatchColor
        {
            get
            {
                return BestMatchR == 0 && BestMatchG == 0 && BestMatchB == 0 ? Colors.Transparent : Color.FromRgb((byte)BestMatchR, (byte)BestMatchG, (byte)BestMatchB);
            }
        }

        public Brush BestMatchBrush
        {
            get { return new SolidColorBrush(BestMatchColor); }
        }

        public String LogicalLength
        {
            get
            {
                var length = MachineType == MachineTypes.Eureka ? JobRun.JobLogicalLength * 4 : JobRun.JobLogicalLength;
                return JobRun.NumberOfUnits > 1 ? $"{length} x{JobRun.NumberOfUnits}" : length.ToString();
            }
        }

        public double LogicalLengthMeters
        {
            get
            {
                return (MachineType == MachineTypes.Eureka ? JobRun.JobLogicalLength * 4 : JobRun.JobLogicalLength);
            }
        }

        public double JobLength
        {
            get { return MachineType == MachineTypes.Eureka ? JobRun.JobLength * 4 : JobRun.JobLength; }
        }

        public double EndPosition
        {
            get { return MachineType == MachineTypes.Eureka ? JobRun.EndPosition * 4 : JobRun.EndPosition; }
        }

        public double ActualStartPosition
        {
            get { return MachineType == MachineTypes.Eureka ? JobRun.ActualStartPosition * 4 : JobRun.ActualStartPosition; }
        }

        public double ActualEndPosition
        {
            get
            {
                if (JobRun.ActualEndPosition > 0)
                {
                    return MachineType == MachineTypes.Eureka ? JobRun.ActualEndPosition * 4 : JobRun.ActualEndPosition;
                }
                else
                {
                    return MachineType == MachineTypes.Eureka ? JobRun.EndPosition * 4 : JobRun.EndPosition;
                }
            }
        }

        public double ActualLength
        {
            get { return LogicalLengthMeters * JobRun.NumberOfUnits; }
        }

        public String FineTuningMeasured
        {
            get
            {
                if (FineTuningModel == null) return "";

                return $"{FineTuningModel.FineTuningMeasuredL}, {FineTuningModel.FineTuningMeasuredA}, {FineTuningModel.FineTuningMeasuredB}";
            }
        }

        public String FineTuningSuggested
        {
            get
            {
                if (FineTuningModel == null) return "";

                return $"{FineTuningModel.FineTuningSuggestionL.ToString("0.00")}, {FineTuningModel.FineTuningSuggestionA.ToString("0.00")}, {FineTuningModel.FineTuningSuggestionB.ToString("0.00")}";
            }
        }

        public String FineTuningLCH
        {
            get
            {
                if (FineTuningModel == null) return "";

                return $"{FineTuningModel.Lightness.ToString("0.0")}, {FineTuningModel.Chroma.ToString("0.0")}, {FineTuningModel.Hue.ToString("0.0")}";
            }
        }

        public String FineTuningTarget
        {
            get
            {
                if (FineTuningModel == null) return "";

                return $"{FineTuningModel.FineTuningTargetL.ToString("0.00")}, {FineTuningModel.FineTuningTargetA.ToString("0.00")}, {FineTuningModel.FineTuningTargetB.ToString("0.00")}";
            }
        }

        private double? _fineTuningDeltaE;
        public double? FineTuningDeltaE
        {
            get
            {
                if (_fineTuningDeltaE != null) return _fineTuningDeltaE;
                if (FineTuningModel == null) return null;
                if (FineTuningModel.FineTuningMeasuredL == null) return null;

                var converter = new DefaultColorConverter();

                var deltaE =
                    converter.CalculateDeltaE_CMC(
                    FineTuningModel.FineTuningTargetL,
                    FineTuningModel.FineTuningTargetA,
                    FineTuningModel.FineTuningTargetB,
                    FineTuningModel.FineTuningMeasuredL.Value,
                    FineTuningModel.FineTuningMeasuredA.Value,
                    FineTuningModel.FineTuningMeasuredB.Value);

                _fineTuningDeltaE = Math.Round(deltaE, 2);

                return _fineTuningDeltaE;
            }
            private set { _fineTuningDeltaE = value; }
        }

        public double Distance
        {
            get
            {
                return ActualEndPosition - ActualStartPosition;
            }
        }

    }
}