using System;
using System.ComponentModel;
using System.Windows;
using BeWo.Validation;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;

namespace BeWo.ViewModel
{
	public class AbsenceTimeVM : AbstractDCMapperVM<AbsenceTimeDC>, IDataErrorInfo
	{
		public static string PropertyName_End = "End";

		public static string PropertyName_Notice = "Notice";

		public static string PropertyName_Reason = "Reason";

		public static string PropertyName_Start = "Start";

	    public static string PropertyName_KrankheitsMeldung = "KrankheitsMeldung";

		private DateTime? _End;

		private string _Notice;

		private AbsenceReasonDC _Reason;

		private DateTime? _Start;

	    private DateTime? _KrankheitsMeldung;

        private string _BackgroundColor;

		public AbsenceTimeVM(AbsenceTimeDC pDC) : base(pDC, pDC.AbsenceTimeOid == null) {}

		public DateTime? End
		{
			get => _End;

            set
			{
				if (AreDifferent(_End, value))
				{
					_End = value;
					StoreDirtyInformation(AreDifferent(DataContract.End, value), PropertyName_End);
					FirePropertyChanged(PropertyName_End);
                    FirePropertyChanged(nameof(Start));
                    FirePropertyChanged(nameof(EndTime));
				}
			}
		}

		public string Notice
		{
			get => _Notice;

            set
			{
				if (AreDifferent(_Notice, value))
				{
					_Notice = value;
					StoreDirtyInformation(AreDifferent(DataContract.Notice, value), PropertyName_Notice);
					FirePropertyChanged(PropertyName_Notice);
				}
			}
		}

		[Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
		public AbsenceReasonDC Reason
		{
			get => _Reason;

            set
			{
				if (AreDifferent(_Reason, value))
				{
					_Reason = value;
					StoreDirtyInformation(!AreEqual(value, DataContract.Reason), PropertyName_Reason);
					FirePropertyChanged(PropertyName_Reason);
				}
			}
		}

		[Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
		public DateTime? Start
		{
			get => _Start;

            set
			{
				if (AreDifferent(_Start, value))
				{
					_Start = value;
					StoreDirtyInformation(AreDifferent(DataContract.Start, value), PropertyName_Start);
					FirePropertyChanged(PropertyName_Start);
					FirePropertyChanged(nameof(End));
					FirePropertyChanged(nameof(StartTime));
				}
			}
		}

        private bool _IsAllDay;

        public bool IsAllDay
        {
            get => _IsAllDay;

            set
            {
                if (AreDifferent(_IsAllDay, value))
                {
                    _IsAllDay = value;

                    Start = _Start?.MergeDatesByDate(_Start.Value.Date);
                    End = _End?.MergeDatesByDate(_End.Value.Date);

                    FirePropertyChanged(nameof(IsAllDay));
                    FirePropertyChanged(nameof(DateEditColumnSpan));
                }
            }
        }

        public string StartTime
        {
            get
            {
                if (_Start != null && _Start.Value.Hour == 0 && _Start.Value.Minute == 0)
                {
                    return "";
                }
                return _Start?.ToString("HH:mm");
            }

            set
            {
                if (_Start.HasValue && DateTime.TryParse($"{_Start.Value.ToLongDateString()} {value}", out var newTime))
                {
                    Start = newTime;
                }
            }
	    }

	    public string EndTime
	    {
	        get
	        {
	            if (_End != null && _End.Value.Hour == 0 && _End.Value.Minute == 0)
	            {
	                return "";
	            }
                return _End?.ToString("HH:mm");
	        }

	        set
            {
                if (_End.HasValue && DateTime.TryParse($"{_End.Value.ToLongDateString()} {value}", out var newTime))
                {
                    End = newTime;
                }
			}
	    }

		public string BackgroundColor
		{
			get => _BackgroundColor;

			set
			{
				if (AreDifferent(_BackgroundColor, value))
				{
					_BackgroundColor = value;
					StoreDirtyInformation(AreDifferent(DataContract.BackgroundColor, value), _BackgroundColor);
					FirePropertyChanged(_BackgroundColor);
				}
			}
		}

		[Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
        public DateTime? KrankheitsMeldung
        {
            get => _KrankheitsMeldung;

            set
            {
                if (AreDifferent(_KrankheitsMeldung, value))
                {
                    _KrankheitsMeldung = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Start, value), PropertyName_KrankheitsMeldung);
                    FirePropertyChanged(PropertyName_KrankheitsMeldung);
                }
            }
        }

        public int DateEditColumnSpan => _IsAllDay ? 2 : 1;

        protected override void InitByDataContract(AbsenceTimeDC pDataContract)
		{
			if (!IsNew)
			{
				_Start = pDataContract.Start;
				_End = pDataContract.End;
				_Notice = pDataContract.Notice;

				_Reason = pDataContract.Reason;
			    _KrankheitsMeldung = pDataContract.KrankheitsMeldung;

                _IsAllDay = _Start.HasValue && _Start.Value.IsTimeZero() && (_End == null || _End.Value.IsTimeZero());
            }
            else
            {
                _IsAllDay = true;
            }
		}

		protected override AbsenceTimeDC MapToDataContract(AbsenceTimeDC pDataContract, bool doCommit)
		{
			if (_Reason != null)
			{
				pDataContract.Reason = _Reason;
			}

			pDataContract.Start  = _Start;
			pDataContract.End    = _End;
			pDataContract.Notice = _Notice;

		    pDataContract.KrankheitsMeldung = _KrankheitsMeldung;

			return pDataContract;
		}

        string IDataErrorInfo.Error
        {
            get
            {
                var me = (IDataErrorInfo)this;
                var error = me[nameof(Start)] +
                            me[nameof(End)] +
                            me[nameof(Reason)];

                return error;
            }
        }

        string IDataErrorInfo.this[string columnName]
        {
            get
            {
                if (columnName.Equals(nameof(Start)) && Start == null)
                {
                    return "Das Startdatum muss einen Wert haben.\n";
                }

                if (columnName.Equals(nameof(End)) && End != null && End.Value < Start)
                {
                    return "Das Startdatum muss vor dem Enddatum liegen.\n";
                }

                if (columnName.Equals(nameof(Reason)) && Reason == null)
                {
                    return "Die Kategorie darf nicht leer sein.\n";
                }

                return null;
            }
        }

        public void ValidateDates(Action callback)
        {
            var error = ((IDataErrorInfo) this).Error;

            if (!string.IsNullOrEmpty(error))
            {
                MessageBox.Show(error, "Ungültige Eingabe", MessageBoxButton.OK, MessageBoxImage.Error);
				FirePropertyChanged(nameof(Start));
				FirePropertyChanged(nameof(End));
				FirePropertyChanged(nameof(Reason));
			}
            else
            {
                callback();
            }
        }
	}
}