using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Enumerations;
using Tango.BL.ValueObjects;
using Tango.PMR.Exports;

namespace Tango.BL.Entities
{
    public partial class JobRun : JobRunBase
    {
        private List<JobRunLiquidQuantity> _liquidQuantities;

        [NotMapped]
        [JsonIgnore]
        public JobRunStatus JobRunStatus
        {
            get { return (JobRunStatus)Status; }
            set { Status = (int)value; }
        }

        /// <summary>
        /// Gets or sets the job designation.
        /// </summary>
        [NotMapped]
        [JsonIgnore]
        public JobDesignations Designation
        {
            get { return (JobDesignations)JobDesignation; }
            set { JobDesignation = value.ToInt32(); RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Gets or sets the job designation.
        /// </summary>
        [NotMapped]
        [JsonIgnore]
        public JobSource Source
        {
            get { return (JobSource)JobSource; }
            set { JobSource = value.ToInt32(); RaisePropertyChangedAuto(); }
        }

        [NotMapped]
        [JsonIgnore]
        public List<JobRunLiquidQuantity> LiquidQuantities
        {
            get
            {
                if (_liquidQuantities == null)
                {
                    if (LiquidQuantityString != null)
                    {
                        try
                        {
                            _liquidQuantities = JsonConvert.DeserializeObject<List<JobRunLiquidQuantity>>(LiquidQuantityString);
                        }
                        catch
                        {
                            _liquidQuantities = new List<JobRunLiquidQuantity>();
                        }
                    }
                    else
                    {
                        _liquidQuantities = new List<JobRunLiquidQuantity>();
                    }
                }

                return _liquidQuantities;
            }
            set
            {
                _liquidQuantities = value;

                if (_liquidQuantities != null)
                {
                    LiquidQuantityString = JsonConvert.SerializeObject(_liquidQuantities);
                }
            }
        }


        private List<JobRunLiquidQuantity> _liquidQuantitiesFast;
        [NotMapped]
        [JsonIgnore]
        public List<JobRunLiquidQuantity> LiquidQuantitiesFast
        {
            get
            {
                if (_liquidQuantitiesFast == null)
                {
                    _liquidQuantitiesFast = new List<JobRunLiquidQuantity>();

                    // Cache all properties once for faster lookup
                    var props = this.GetType()
                                    .GetProperties()
                                    .Where(p => p.Name.EndsWith("Quantity", StringComparison.OrdinalIgnoreCase))
                                    .ToDictionary(p => p.Name.ToLowerInvariant());

                    foreach (LiquidTypes lt in Enum.GetValues(typeof(LiquidTypes)))
                    {
                        string expectedPropName = (lt.ToString() + "Quantity").ToLowerInvariant();

                        if (props.TryGetValue(expectedPropName, out var prop))
                        {
                            var value = prop.GetValue(this);
                            if (value != null)
                            {
                                _liquidQuantitiesFast.Add(new JobRunLiquidQuantity()
                                {
                                    LiquidType = lt,
                                    Quantity = Convert.ToInt64(value)
                                });
                            }
                        }
                    }
                }

                return _liquidQuantitiesFast;
            }
        }

        private JobFile _jobFile;
        [NotMapped]
        [JsonIgnore]
        public JobFile JobFile
        {
            get
            {
                if (_jobFile == null && JobString != null)
                {
                    _jobFile = JobFile.Parser.ParseJson(JobString);
                }

                return _jobFile;
            }
            set { _jobFile = value; }
        }

        public Task<Job> CreateAssociatedJob()
        {
            return Job.FromJobFile(JobFile, MachineGuid, UserGuid);
        }

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

            if (propName == nameof(Status))
            {
                RaisePropertyChanged(nameof(JobRunStatus));
            }
        }


        [NotMapped]
        [JsonIgnore]
        public TimeSpan TotalDyeingTime
        {
            get
            {
                if (this.ActualStartDate == null || this.EndDate == default(DateTime) || this.EndDate < this.ActualStartDate)
                    return TimeSpan.Zero;

                return EndDate - (DateTime)ActualStartDate;

            }

        }

        [NotMapped]
        [JsonIgnore]
        public double Distance
        {
            get
            {
                return (ActualEndPosition > 0 ? ActualEndPosition : EndPosition) - ActualStartPosition;
            }
        }

        [NotMapped]
        [JsonIgnore]
        public MachineTypes MachineTypeEnum
        {
            get
            {
                return (MachineTypes)MachineType;
            }
        }


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

        }
    }
}