using BS.Shared.DataContracts;
using System;
using System.Collections.Generic;

namespace BeWo.ViewModel
{
	public abstract class AbstractDCMapperVM<DCType> : AbstractBaseVM where DCType : new()
	{
		private readonly List<string> _DirtyProps = new List<string>();

		private bool? _IsNew;

		public AbstractDCMapperVM() { }

		public AbstractDCMapperVM(DCType pDataContract, bool pIsNew)
		{
			_IsNew = pIsNew;
			DataContract = pDataContract;
			InitByDataContract(DataContract);
		}

		public AbstractDCMapperVM(DCType pDataContract, long? oid) : this(pDataContract, oid is null) { }

		public override bool IsDirty
		{
			get { return _DirtyProps.Count > 0; }
		}

		public bool IsNew
		{
			get
			{
				if (_IsNew == null)
				{
					throw new NotImplementedException();
				}

				return _IsNew.Value;
			}

			set
			{
				_IsNew = value;
			}
		}

		internal DCType DataContract { get; set; }

		public DCType CommitToDataContract()
		{
			return MapToDataContract(DataContract, true);
		}

		public DCType CopyToEmptyDataContract()
		{
			return MapToDataContract(new DCType(), false);
		}

		public override void SetDirty(bool newDirty)
		{
			if (!newDirty)
			{
				_DirtyProps.Clear();
			}
		}

		protected abstract void InitByDataContract(DCType pDataContract);

		protected abstract DCType MapToDataContract(DCType pDataContract, bool doCommit);

		public virtual void UpdateByDataContract(DCType pDataContract)
		{
			throw new NotImplementedException();
		}

		protected void StoreDirtyInformation(bool pDirty, string pPropName)
		{
			if (_DirtyProps.Contains(pPropName) && !pDirty)
			{
				_DirtyProps.Remove(pPropName);
			}
			else if (!_DirtyProps.Contains(pPropName) && pDirty)
			{
				_DirtyProps.Add(pPropName);
			}
		}

		protected bool SetProperty<T>(ref T field, T value, string propertyName, Func<T> originalValueProvider = null)
		{
			if (EqualityComparer<T>.Default.Equals(field, value))
				return false;

			field = value;

			if (originalValueProvider != null)
			{
				var isDirty = true;
				if(DataContract != null)
				{
					isDirty = !EqualityComparer<T>.Default.Equals(getSafe(originalValueProvider), value);
				}
				StoreDirtyInformation(isDirty, propertyName);
			}

			FirePropertyChanged(propertyName);
			return true;
		}

		private T getSafe<T>(Func<T> originalValueProvider)
		{
			try
			{
				return originalValueProvider();
			}
			catch (Exception e)
			{
				return default(T);
			}
		}
	}
}