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 SbmProcess : SbmHierarchyItem
	{
		//-------------------------------------------------------------------
		// Columns.
		public enum Column
		{
			Hidden,
			Pos,
			//Id,
			//Process.
			Category, Category_Desc,
			Type, Type_Desc,
			Seq,
			DescBrief, DescOutline,
			Default,
			CompletedOn,
			ContractorName,
			AmountNet,
			// Common properties.
			Notes,
			Flag,
			Status,
			Status_Desc,
			Status_Ind,
			CreateOn_Date,
			UpdateOn_Date,
		}

		//-------------------------------------------------------------------
		/// <summary>Properties other than common.</summary>
		public class DataProperties
		{
			public SysId AffiliateIdOwner { get; set; } = new SysId();
			public Sbm.ProcessCategory ProcessCategory { get; set; } = Sbm.ProcessCategory.Unknown;
			public Sbm.ProcessType ProcessType { get; set; } = Sbm.ProcessType.Unknown;
			public short Seq { get; set; } = 0;
			public String DescBrief { get; set; } = "";
			public String DescOutline { get; set; } = "";
		}

		// Data.
		public new class Data : SacsHierarchyItem.Data
		{
			// Data members.
			private readonly DataProperties data = new DataProperties();
			// Construction.
			public Data()
			{
				Status = DefaultStatus;
			}

			public SysId AffiliateIdOwner
			{
				get { return data.AffiliateIdOwner; }
				set { CheckChanged(data.AffiliateIdOwner, value); data.AffiliateIdOwner = value; }
			}
			public Sbm.ProcessCategory ProcessCategory
			{
				get { return data.ProcessCategory; }
				set { CheckChanged((int)data.ProcessCategory, (int)value); data.ProcessCategory = value; }
			}
			public Sbm.ProcessType ProcessType
			{
				get { return data.ProcessType; }
				set { CheckChanged((int)data.ProcessType, (int)value); data.ProcessType = value; }
			}

			public short Seq
			{
				get { return data.Seq; }
				set { CheckChanged(data.Seq, value); data.Seq = value; }
			}
			public String DescBrief
			{
				get { return data.DescBrief; }
				set { CheckChanged(data.DescBrief, value); data.DescBrief = value; }
			}
			public String DescOutline
			{
				get { return data.DescOutline; }
				set { CheckChanged(data.DescOutline, value); data.DescOutline = value; }
			}

			internal void PopulateFrom(Data data)
			{
				AffiliateIdOwner = data.AffiliateIdOwner;
				ProcessCategory = data.ProcessCategory;
				ProcessType = data.ProcessType;
				Seq = data.Seq;
				DescBrief = data.DescBrief;
				DescOutline = data.DescOutline;
				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 AffiliateIdOwner { get; set; } = ValidValue.Valid;
			public ValidValue ProcessCategory { get; set; } = ValidValue.Valid;
			public ValidValue ProcessType { get; set; } = ValidValue.Valid;
			public ValidValue Seq { get; set; } = ValidValue.Valid;
			public ValidValue DescBrief { get; set; } = ValidValue.Valid;
			public ValidValue DescOutline { get; set; } = ValidValue.Valid;
		}

		//-------------------------------------------------------------------
		// Data members.
		private readonly Data data = new Data();
		public static readonly Byte Flag_Default = 0x01;
		public static readonly Byte Flag_SubContracted = 0x02;

		//-------------------------------------------------------------------
		// Construction.
		protected SbmProcess(ISbmUserContext userContext, SysId id, SysId affiliateIdOwner, Sbm.ProcessCategory processCategory) : base(userContext, id)
		{
			base.SetData(data);
			AffiliateIdOwner = affiliateIdOwner;
			ProcessCategory = processCategory;
			Status = DefaultStatus;
		}

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

		//-------------------------------------------------------------------
		// Utilities.

		//-------------------------------------------------------------------
		// 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 AffiliateIdOwner
		{
			get { return data.AffiliateIdOwner; }
			set { data.AffiliateIdOwner = value; }
		}
		public Sbm.ProcessCategory ProcessCategory
		{
			get { return data.ProcessCategory; }
			set { data.ProcessCategory = value; }
		}
		public Sbm.ProcessType ProcessType
		{
			get { return data.ProcessType; }
			set { data.ProcessType = value; }
		}

		public short Seq
		{
			get { return data.Seq; }
			set { data.Seq = value; }
		}
		public String DescBrief
		{
			get { return data.DescBrief; }
			set { data.DescBrief = value; }
		}
		public String DescOutline
		{
			get { return data.DescOutline; }
			set { data.DescOutline = value; }
		}

		public enum SbmProcessCostCode
		{
			Fixed_Unit,
			Fixed_Job,
			Labour_Unit,
			Labour_Job,
		};

		public SbmProcessCostCode GetCostCodeType(Sbm.CostEstimateCategory costEstimateCategory)
		{
			switch (costEstimateCategory)
			{
				case Sbm.CostEstimateCategory.CostPerUnit:
					return SbmProcessCostCode.Fixed_Unit;
				case Sbm.CostEstimateCategory.CostPerJob:
					return SbmProcessCostCode.Fixed_Job;
				case Sbm.CostEstimateCategory.LabourPerUnit:
					return SbmProcessCostCode.Labour_Unit;
				case Sbm.CostEstimateCategory.LabourPerJob:
					return SbmProcessCostCode.Labour_Job;
			}
			return 0;
		}

		//-------------------------------------------------------------------
		// Flags.
		public bool Default
		{
			get { return GetFlag(Flag_Default); }
			set { SetFlag(Flag_Default, value); }
		}
		public bool SubContracted
		{
			get { return GetFlag(Flag_SubContracted); }
			set { SetFlag(Flag_SubContracted, value); }
		}


		//-------------------------------------------------------------------
		//                  A s s o c i a t e d   C o d e s
		//-------------------------------------------------------------------
		public abstract String GetCodeForCostCode(SbmProcessCostCode processCostCode);
		public abstract bool HasCostCodes();
		public abstract bool HasCostCodes(SbmProcessCostCode processCostCode);
		public abstract List<String> GetCostCodes(SbmProcessCostCode processCostCode);
		public abstract bool StoreCostCodes(SbmProcessCostCode processCostCode, List<String> costCodes);
		public abstract bool ClearCostCodes(SbmProcessCostCode processCostCode);
		public abstract bool ClearCostCodes();

		//-------------------------------------------------------------------
		//          A s s o c i a t e d   D a t a   E l e m e n t s          
		//-------------------------------------------------------------------
		public abstract bool HasReferences();
		public abstract bool HasItemData();
		public abstract bool ClearAssociatedData();

		//-------------------------------------------------------------------
		//                            P a r a m s
		//-------------------------------------------------------------------
		/// <summary>Parameters - used to define the filters that should be applied to a List of Processes</summary>
		// List parameters.
		public enum StatusCat
		{
			Any,
		}
		/// <summary>
		/// Item list parameters.
		/// </summary>
		public new class Params : SacsHierarchyItem.Params
		{
			// List filtering.
			public List<SysId> IncludedIds { get; } = new List<SysId>();
			public List<SysId> ExcludedIds { get; } = new List<SysId>();

			// Process.
			public Sbm.ProcessCategory ProcessCategory { get; set; }
			public Sbm.ProcessType ProcessType { get; set; }
			public short Seq { get; set; }
			public String DescBrief { get; set; }
			public bool RestrictToActive { get; set; }
			public bool RestrictToDefaults { get; set; }

			public StatusCat StatusCat { get; set; } = StatusCat.Any;
			// Assignment.
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
	//             P r o c e s s   D a t a   L i s t
	//=======================================================================
	public static class SbmProcessList
	{
		/// <summary>Check whether currency exists/locate in list with specified Id.</summary>

		//-------------------------------------------------------------------
		// Resequence - sets sequence numbers from '1' at start of list.
		public static bool Resequence(this List<SbmProcess> values, SbmProcess processSeq)
		{
			bool bValid = true;
			if (values != null || values.Count == 0) return false;
			for (int itemIdx = 0; itemIdx < values.Count; itemIdx++)
				values[itemIdx].Seq = (short)(itemIdx + 1);
			return bValid;
		}

		//-------------------------------------------------------------------
		// Find item in the list.
		public static bool Find(this List<SbmProcess> values, SbmProcess process)
		{
			if (process == null) return false;
			return (values.Find(item => item == process) != null);
		}

		public static bool FindById(this List<SbmContainer> values, SysId processId)
		{
			if (!SysId.IsValid(processId)) return false;
			return values.Exists(item => item.Id.Equals(processId));
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
}