using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core;

namespace Tango.PPC.Jobs.Models
{
    public class SegmentsGroupModel : ExtendedObject, ISegmentModel
    {
        #region Properties

        public SynchronizedObservableCollection<SegmentModel> Segments { get; set; }

        private Int32 _segnmentIndex;
        public Int32 SegmentIndex
        {
            get
            {
                return _segnmentIndex;
            }
            set
            {
                if(_segnmentIndex != value)
                {
                    _segnmentIndex = value;
                    RaisePropertyChangedAuto();
                }
            }
        }
        
        private int _repeats;

        public int Repeats
        {
            get { return _repeats; }
            set { _repeats = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(Length));
            }
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value;
                RaisePropertyChangedAuto();
            }
        }

        [JsonIgnore]
        public JobModel Job { get; set; }

        protected Double _length;
        /// <summary>
        /// Gets or sets the length.
        /// </summary>
        public Double Length
        {
            get
            {
                return Segments.Count == 0 ? 0 : Segments.ToList().Sum(x=>x.Length);
            }
            
        }

        
        /// <summary>
        /// Gets or sets the length.
        /// </summary>
        public Double FullLength
        {
            get
            {
                return Segments.Count == 0 ? 0 : Segments.ToList().Sum(x => x.Length) * Repeats;
            }

        }

        public Double LengthWithInterSegment
        {
            get
            {
                if (Job != null )
                {
                    return (EnableInterSegment && Segments.Count>0) ? (Segments.Sum(x=>x.LengthWithInterSegment) * Repeats) : (Length * Repeats);
                }
                return Length;
                //return Segments.Count == 0 ? 0 : Segments.ToList().Sum(x => x.LengthWithInterSegment) * Repeats;
            }
        }

        public bool IsGroupSegment
        {
            get
            {
                return true;
            }
        }

        private bool _isSelected;
        [JsonIgnore]
        public bool IsSelected
        {
            get { return _isSelected; }
            set
            {
                _isSelected = value;
                Segments.ToList().ForEach(x => x.IsSelected = value);
                RaisePropertyChangedAuto();
            }
        }

        private bool _isLast;
        [JsonIgnore]
        public bool IsLast
        {
            get { return _isLast; }
            set
            {
                if (_isLast != value)
                {
                    _isLast = value;
                    RaisePropertyChangedAuto();
                    RaisePropertyChanged(nameof(ShowGap));
                }
            }
        }
        
        public int FirstSegmentIndex {
            get
            {
                return Segments.Count == 0 ? 0: Segments.ToList().Min(x => x.SegmentIndex);
            }
         }
        [JsonIgnore]
        public int LastSegmentIndex {
            get
            {
                return Segments.Count == 0 ? 0 : Segments.ToList().Max(x => x.SegmentIndex);
            }
        }

        public string DisplayIndexes
        {
            get
            {
                return String.Format($"(#{FirstSegmentIndex} - {LastSegmentIndex})");
            }
        }

        public double InterSegmentLength
        {
            get
            {
                 return Job == null ? 0 : Job.InterSegmentLength;
                // return Segments.Count == 0 ? 0 : Segments.ToList().Select(x => x.InterSegmentLength).FirstOrDefault();
            }
        }

        protected Boolean _enableintersegment;
        public Boolean EnableInterSegment
        {
            get { return _enableintersegment; }
            set
            {
                if (_enableintersegment != value)
                {
                    _enableintersegment = value;
                    RaisePropertyChangedAuto();
                }
                RaisePropertyChanged(nameof(LengthWithInterSegment));
                RaisePropertyChanged(nameof(InterSegmentLength));
                RaisePropertyChanged(nameof(ShowGap));

            }
        }

        [JsonIgnore]
        public bool ShowGap
        {
            get
            {
                return EnableInterSegment && !IsLast;
            }
        }
        
        #endregion

        public SegmentsGroupModel(JobModel jobModel, List<SegmentModel> selectedSegments)
        {
            Job = jobModel;
            Segments = selectedSegments.ToSynchronizedObservableCollection();
            Repeats = 1;
            EnableInterSegment = jobModel.EnableInterSegment;
        }

        public SegmentsGroupModel(JobModel jobModel)
        {
            Job = jobModel;
            Segments = new SynchronizedObservableCollection<SegmentModel>();
            Repeats = 1;
            EnableInterSegment = jobModel.EnableInterSegment;
        }

        /// <summary>
        /// Clones this instance.
        /// </summary>
        /// <returns></returns>
        public SegmentsGroupModel Clone()
        {
            SegmentsGroupModel cloned = new SegmentsGroupModel(this.Job);
            cloned.SegmentIndex = this.SegmentIndex;

            cloned.Segments = Segments.Select(x => x.Clone()).ToSynchronizedObservableCollection();

            foreach (var stop in cloned.Segments)
            {
                stop.SegmentsGroupModel= cloned;
            }

            return cloned;
        }

        ISegmentModel ISegmentModel.Clone()
        {
            return Clone() as ISegmentModel;
        }
    }
}