using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Utils;
using System;
using System.Collections.Generic;

namespace Sarand.BusinessMgr.Net.Standard.Base.Bus
{
	//=======================================================================
	public abstract class SbmVehicleFeature : SbmHierarchyItem
	{
		//-------------------------------------------------------------------
		// Vehicle Feature_Id data.
		public class SbmVehicleFeature_Id
		{
			public SbmVehicleFeature_Id()
			{
				VehicleFeatureSource = Sbm.VehicleFeatureSource.Unknown;
				VehicleFeatureType = Sbm.VehicleFeatureType.Unknown;
			}
			public SbmVehicleFeature_Id(SbmVehicleFeature_Id id)
			{
				VehicleId = id.VehicleId;
				VehicleFeatureSource = id.VehicleFeatureSource;
				VehicleFeatureType = id.VehicleFeatureType;
				CategoryCode = id.CategoryCode;
				FeatureCode = id.FeatureCode;
			}
			public SysId VehicleId;
			public Sbm.VehicleFeatureSource VehicleFeatureSource;
			public Sbm.VehicleFeatureType VehicleFeatureType;
			public String CategoryCode;
			public String FeatureCode;

		}

		//-------------------------------------------------------------------
		// Columns.
		public enum Column
		{
			Hidden,
			Pos,
			//Id,
			// VehicleFeature.
			VehicleId,
			Vehicle_RegNumber,
			FeatureSourceDesc,
			FeatureTypeDesc,
			Category,              // Displayed as code and description.
			CategoryCode,
			CategoryDesc,
			Feature,               // Displayed as code and description.
			FeatureCode,
			FeatureDesc,
			// Common properties.
			Notes,
			Flag,
			Status,
			Status_Ind,
			Status_Desc,
			CreateOn_Date,
			UpdateOn_Date,
		}


		//-------------------------------------------------------------------
		/// <summary>Properties other than common.</summary>
		public class DataProperties
		{
			public SysId VehicleId { get; set; } = new SysId();
			public Sbm.VehicleFeatureSource VehicleFeatureSource { get; set; } = Sbm.VehicleFeatureSource.Unknown;
			public Sbm.VehicleFeatureType VehicleFeatureType { get; set; } = Sbm.VehicleFeatureType.Unknown;
			public String CategoryCode { get; set; } = "";
			public String CategoryDesc { get; set; } = "";
			public String FeatureCode { get; set; } = "";
			public String FeatureDesc { get; set; } = "";
		}

		// Data.
		public new class Data : SacsHierarchyItem.Data
		{
			// Data members.
			private readonly DataProperties data = new DataProperties();
			// Construction.
			public Data()
			{
				Status = DefaultStatus;
			}
			public SysId VehicleId
			{
				get { return data.VehicleId; }
				set { CheckChanged(data.VehicleId, value); data.VehicleId = value; }
			}
			public Sbm.VehicleFeatureSource VehicleFeatureSource
			{
				get { return data.VehicleFeatureSource; }
				set { CheckChanged((int)data.VehicleFeatureSource, (int)value); data.VehicleFeatureSource = value; }
			}
			public Sbm.VehicleFeatureType VehicleFeatureType
			{
				get { return data.VehicleFeatureType; }
				set { CheckChanged((int)data.VehicleFeatureType, (int)value); data.VehicleFeatureType = value; }
			}
			public String CategoryCode
			{
				get { return data.CategoryCode; }
				set { CheckChanged(data.CategoryCode, value); data.CategoryCode = value; }
			}
			public String CategoryDesc
			{
				get { return data.CategoryDesc; }
				set { CheckChanged(data.CategoryDesc, value); data.CategoryDesc = value; }
			}
			public String FeatureCode
			{
				get { return data.FeatureCode; }
				set { CheckChanged(data.FeatureCode, value); data.FeatureCode = value; }
			}

			public String FeatureDesc
			{
				get { return data.FeatureDesc; }
				set { CheckChanged(data.FeatureDesc, value); data.FeatureDesc = value; }
			}

			internal void PopulateFrom(Data data)
			{
				VehicleId = data.VehicleId;
				VehicleFeatureSource = data.VehicleFeatureSource;
				VehicleFeatureType = data.VehicleFeatureType;
				CategoryCode = data.CategoryCode;
				CategoryDesc = data.CategoryDesc;
				FeatureCode = data.FeatureCode;
				FeatureDesc = data.FeatureDesc;
				base.PopulateFrom(data);
			}
			public Data Clone()
			{
				Data data = new Data();
				data.PopulateFrom(this);
				return data;
			}
		}

		public new class ErrField : SacsHierarchyItem.ErrField
		{
			// Identifies the field that has invalid data.
			public ValidValue VehicleId { get; set; } = ValidValue.Valid;
			public ValidValue VehicleFeatureSource { get; set; } = ValidValue.Valid;
			public ValidValue VehicleFeatureType { get; set; } = ValidValue.Valid;
			public ValidValue CategoryCode { get; set; } = ValidValue.Valid;
			public ValidValue CategoryDesc { get; set; } = ValidValue.Valid;
			public ValidValue FeatureCode { get; set; } = ValidValue.Valid;
			public ValidValue FeatureDesc { get; set; } = ValidValue.Valid;
		}

		//-------------------------------------------------------------------
		// Data members.
		private readonly Data data = new Data();

		//-------------------------------------------------------------------
		// Construction.
		protected SbmVehicleFeature(ISbmUserOrganisationContext userContext, SysId vehicleId, Sbm.VehicleFeatureSource vehicleFeatureSource, Sbm.VehicleFeatureType vehicleFeatureType) : base(userContext)
		{
			base.SetData(data);
			VehicleId = vehicleId;
			VehicleFeatureSource = vehicleFeatureSource;
			VehicleFeatureType = vehicleFeatureType;
			Status = DefaultStatus;
		}

		//-------------------------------------------------------------------
		// VehicleFeature status.
		private static readonly List<SaStatus> vehicleFeatureStatuses = new List<SaStatus>()
		{
			SaStatus.Active,
			SaStatus.Cancelled,
		};
		public static SaStatus DefaultStatus { get { return SaStatus.Current; } }
		public static List<SaStatus> ValidStatuses { get { return new List<SaStatus>(vehicleFeatureStatuses); } }
		public static DataValue.TriStateType GetStatusTriState(SaStatus status)
		{
			switch (status)
			{
				case SaStatus.Active:
					return DataValue.TriStateType.Green;
				case SaStatus.Awaiting:
					return DataValue.TriStateType.Amber;
				case SaStatus.Disabled:
					return DataValue.TriStateType.Red;
				case SaStatus.Cancelled:
					return DataValue.TriStateType.Red;
				case SaStatus.Deleted:
					return DataValue.TriStateType.Purple;
			}
			return DataValue.TriStateType.Unknown;
		}

		//-------------------------------------------------------------------
		// Utilities.
		public ItemId GetItemId()
		{
			return new ItemId((short)Sbm.ItemType.VehicleFeature, Id);
		}

		public bool PublishInPreferenceTo(SbmVehicleFeature vehicleFeature)
		{
			// True if different types:
			if (vehicleFeature.VehicleFeatureType != VehicleFeatureType) return true;
			// True if different category (for technical, equipment or options).
			if (vehicleFeature.CategoryCode != CategoryCode)
			{
				switch (VehicleFeatureType)
				{
					case Sbm.VehicleFeatureType.Technical:
					case Sbm.VehicleFeatureType.Equipment:
					case Sbm.VehicleFeatureType.OptionalExtra:
						return true;
				}
			}// Compare source:
			Sbm.VehicleFeatureSource vehicleFeatureSource = vehicleFeature.VehicleFeatureSource;
			// Don't publish SMMT features if another source is available.
			if (VehicleFeatureSource == Sbm.VehicleFeatureSource.SMMT && vehicleFeatureSource == Sbm.VehicleFeatureSource.SMMT) return false;
			// Publish DVLA features in preference to SMMT only:
			if (VehicleFeatureSource == Sbm.VehicleFeatureSource.DVLA && vehicleFeatureSource == Sbm.VehicleFeatureSource.DVLA) return false;
			// Publish HPI features in preference to DVLA only:
			if (VehicleFeatureSource == Sbm.VehicleFeatureSource.HPI && vehicleFeatureSource == Sbm.VehicleFeatureSource.HPI) return false;
			// Publish CAP features in preference to HPI only:
			if (VehicleFeatureSource == Sbm.VehicleFeatureSource.CAP && vehicleFeatureSource == Sbm.VehicleFeatureSource.CAP) return false;
			// Always publish manually sourced features:
			if (VehicleFeatureSource == Sbm.VehicleFeatureSource.Manual) return true;
			return false;
		}


		//-------------------------------------------------------------------
		// Properties.
		public Data GetData() { return data.Clone(); }
		public void SetData(Data data)
		{
			// Properties that cannot be changed if previously specified.
			if (SysId.IsValid(Id) && SysId.ToInt(Id) != SysId.ToInt(data.Id))
				throw new NotSupportedException($"{SysUtil.Fn} Id cannot be changed");
			// Populate individual properties to ensure that 'Changed' indicator is kept up to date.
			this.data.PopulateFrom(data);
		}

		//-------------------------------------------------------------------
		// Attributes.
		public SysId VehicleId
		{
			get { return data.VehicleId; }
			set { data.VehicleId = value; }
		}
		public Sbm.VehicleFeatureSource VehicleFeatureSource
		{
			get { return data.VehicleFeatureSource; }
			set { data.VehicleFeatureSource = value; }
		}
		public Sbm.VehicleFeatureType VehicleFeatureType
		{
			get { return data.VehicleFeatureType; }
			set { data.VehicleFeatureType = value; }
		}
		public String CategoryCode
		{
			get { return data.CategoryCode; }
			set { data.CategoryCode = value; }
		}
		public String CategoryDesc
		{
			get { return data.CategoryDesc; }
			set { data.CategoryDesc = value; }
		}
		public String FeatureCode
		{
			get { return data.FeatureCode; }
			set { data.FeatureCode = value; }
		}

		public String FeatureDesc
		{
			get { return data.FeatureDesc; }
			set { data.FeatureDesc = value; }
		}

		//-------------------------------------------------------------------
		//          A s s o c i a t e d   D a t a   E l e m e n t s          
		//-------------------------------------------------------------------

		//-------------------------------------------------------------------
		//                            P a r a m s
		//-------------------------------------------------------------------
		/// <summary>Parameters - used to define the filters that should be applied to a List of Vehicle Features</summary>
		// List parameters.
		public enum StatusCat
		{
			Any,
		}
		/// <summary>
		/// Item list parameters.
		/// </summary>
		public new class Params : SacsHierarchyItem.Params
		{
			// List filtering.
			public List<SysId> IdsIncluded { get; } = new List<SysId>();
			public List<SysId> IdsExcluded { get; } = new List<SysId>();
			// VehicleFeature.
			public SysId VehicleId { get; set; }
			public Sbm.VehicleFeatureSource VehicleFeatureSource { get; set; } = Sbm.VehicleFeatureSource.Any;
			public Sbm.VehicleFeatureType VehicleFeatureType { get; set; } = Sbm.VehicleFeatureType.Any;
			public String CategoryCode { get; set; }
			public String FeatureCode { get; set; }
			public bool FullFeatureId { get; set; }
			/// <summary>Vehicle Feature status.</summary>
			public StatusCat StatusCat { get; set; } = StatusCat.Any;
			// Utilities.
			public List<StringPair> GetDisplayValues()
			{
				List<StringPair> values = new List<StringPair>();
				return values;
			}
		}

		//-------------------------------------------------------------------
	}

	//=======================================================================
	//                V e h i c l e   F e a t u r e   L i s t
	//=======================================================================
	public static class SbmVehicleFeatureList
	{
		/// <summary>Check whether currency exists/locate in list with specified Id.</summary>
		public static bool Find(this List<SbmVehicleFeature> values, SbmVehicleFeature vehicleClass)
		{
			if (vehicleClass == null) return false;
			return (values.Find(item => item == vehicleClass) != null);
		}
		public static bool FindByType(this List<SbmVehicleFeature> values, Sbm.VehicleFeatureType vehicleFeatureType)
		{
			if (vehicleFeatureType < 0) return false;
			return values.Exists(item => item.VehicleFeatureType.Equals(vehicleFeatureType));
		}
		public static bool FindBySourceType(this List<SbmVehicleFeature> values, Sbm.VehicleFeatureSource vehicleFeatureSource, Sbm.VehicleFeatureType vehicleFeatureType)
		{
			if (vehicleFeatureSource < 0 && vehicleFeatureType < 0) return false;
			return values.Exists(item => item.VehicleFeatureSource.Equals(vehicleFeatureSource) && item.VehicleFeatureType.Equals(vehicleFeatureType));
		}
		public static List<SbmVehicleFeature> GetFeaturesOfSource(this List<SbmVehicleFeature> values, Sbm.VehicleFeatureSource vehicleFeatureSource)
		{
			return values.FindAll(item => item.VehicleFeatureSource == vehicleFeatureSource);
		}

		public static List<SbmVehicleFeature> GetFeaturesOfType(this List<SbmVehicleFeature> values, Sbm.VehicleFeatureType vehicleFeatureType)
		{
			return values.FindAll(item => item.VehicleFeatureType == vehicleFeatureType);
		}
		public static void AddPrincipalFeaturesOfType(this List<SbmVehicleFeature> values, Sbm.VehicleFeatureType vehicleFeatureType)
		{
			List<SbmVehicleFeature> vehicleFeatures = values.GetFeaturesOfType(vehicleFeatureType);

			switch (vehicleFeatureType)
			{
				case Sbm.VehicleFeatureType.Technical:
				case Sbm.VehicleFeatureType.Equipment:
				case Sbm.VehicleFeatureType.OptionalExtra:
					// Take all features of these types for now:
					values.AddRange(vehicleFeatures);
					break;
				default:
					{
						// Pick the single feature of this type that should be treated as the 'principle':
						SbmVehicleFeature vehicleFeature = null;
						foreach (SbmVehicleFeature vFeature in vehicleFeatures)
						{
							if (vFeature == null)
								vehicleFeature = vehicleFeatures[0];
							else
							{
								if (vFeature.PublishInPreferenceTo(vehicleFeatures[0]))
									vehicleFeature = vehicleFeatures[0];
							}
						}
						if (vehicleFeature != null)
							values.Add(vehicleFeature);
						break;
					}
			}
		}
	}

	//=======================================================================
}