using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.CodeTypes;
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 class SbmTransactionPayment : SbmHierarchyItem
	{
		//-------------------------------------------------------------------
		// Columns.
		public enum Column
		{
			Hidden,
			Pos,
			Id,
			// TransactionPayment.
			// Common properties.
			Notes,
			Status,
			Status_Ind,
			Status_Desc,
			CreateOn_Date,
			UpdateOn_Date,
		}

		//-------------------------------------------------------------------
		/// <summary>Properties other than common.</summary>
		public class DataProperties
		{
			public String Type { get; set; } = "";
			public decimal Amount { get; set; } = 0.0m;
			public ushort CodeSeq { get; set; } = 0;
		}

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

			public String Type
			{
				get { return data.Type; }
				set { CheckChanged(data.Type, value); data.Type = value; }
			}
			public decimal Amount
			{
				get { return data.Amount; }
				set { CheckChanged(data.Amount, value); data.Amount = value; }
			}
			public ushort CodeSeq
			{
				get { return data.CodeSeq; }
				set { CheckChanged(data.CodeSeq, value); data.CodeSeq = value; }
			}

			internal void PopulateFrom(Data data)
			{
				Type = data.Type;
				Amount = data.Amount;
				CodeSeq = data.CodeSeq;
				base.PopulateFrom(data);
			}
			public Data Clone()
			{
				Data data = new Data();
				data.PopulateFrom(this);
				return data;
			}
		}

		//-------------------------------------------------------------------
		// Data members.
		private readonly Data data = new Data();
		private readonly String type;
		private readonly decimal amount = 0.0m;
		// Static Definition.
		private static String delimArchive = "#~#";

		//-------------------------------------------------------------------
		// Construction.
		public SbmTransactionPayment(SbmUserContext userContext) : base(userContext)
		{
			Status = DefaultStatus;
		}
		// Conversion from ItemLink.
		public SbmTransactionPayment(SbmUserContext userContext, String archive) : base(userContext)
		{
			String[] data = archive.Split(new String[] { delimArchive }, StringSplitOptions.None);
			type = (data.Length > 1 ? data[1] : "");
			amount = (data.Length > 2 ? StringUtil.ToDecimal(data[2]) : 0.0m);
		}

		//-------------------------------------------------------------------
		// TransactionPayment status.
		private static readonly List<SaStatus> containerItemStatuses = new List<SaStatus>()
		{
			SaStatus.Active,
			SaStatus.Disabled,
		};
		public static SaStatus DefaultStatus { get { return SaStatus.Current; } }
		public static List<SaStatus> TransactionPaymentStatuses { get { return new List<SaStatus>(containerItemStatuses); } }
		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.Disabled:
					return DataValue.TriStateType.Red;
				case SaStatus.Deleted:
					return DataValue.TriStateType.Purple;
			}
			return DataValue.TriStateType.Unknown;
		}

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

		// Matching.
		public bool MatchesByType(String type)
		{
			if (Type != type) return false;
			return true;
		}

		// Cloning - make a copy of the item.
		public SbmTransactionPayment Clone()
		{
			SbmTransactionPayment transactionPaymentCost = new SbmTransactionPayment(UserContext);
			//transactionPaymentCost.CopyAttributesFrom(this);
			transactionPaymentCost.Type = Type;
			transactionPaymentCost.Amount = Amount;
			//transactionPaymentCost.Changed = false;
			return transactionPaymentCost;
		}

		// Conversion.
		public String Conversion()
		{
			String archive = "";
			archive += Type.ToString() + delimArchive;
			archive += StringUtil.FormatNumeric(Amount, 4) + delimArchive;
			return archive;
		}

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

		//-------------------------------------------------------------------
		// Attributes.
		public String Type
		{
			get { return data.Type; }
			set { data.Type = value; }
		}
		public decimal Amount
		{
			get { return data.Amount; }
			set { data.Amount = value; }
		}
		public ushort CodeSeq
		{
			get { return data.CodeSeq; }
			set { data.CodeSeq = value; }
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
	//            C o s t   E s t i m a t e   D a t a   L i s t            
	//=======================================================================
	public static class SbmTransactionPaymentList
	{
		/// <summary>Check whether currency exists/locate in list with specified Id.</summary>
		//-------------------------------------------------------------------
		// Find.
		public static bool Find(this List<SbmTransactionPayment> values, SbmTransactionPayment containerItem)
		{
			if (containerItem == null) return false;
			return (values.Find(item => item == containerItem) != null);
		}
		public static bool FindByType(this List<SbmTransactionPayment> values, String type)
		{
			if (StringUtil.IsEmpty(type)) return false;
			return values.Exists(item => item.MatchesByType(type));
		}
		//-------------------------------------------------------------------
		public static void SetTypeCodeSequence(this List<SbmTransactionPayment> values, List<SaCodeDfn> typeCodeDfns)
		{
			if (typeCodeDfns == null) return;

			foreach (SbmTransactionPayment transactionPayment in values)
			{
				// Retrieve the next item in the list.
				SbmTransactionPayment transactionPaymentEst = values[StringUtil.ToInt(transactionPayment)];
				if (typeCodeDfns != null && typeCodeDfns.Exists(item => item.Code.Equals(transactionPaymentEst.Type)))
					transactionPaymentEst.CodeSeq = typeCodeDfns.Find(item => item.Code.Equals(transactionPaymentEst.CodeSeq)).Sequence;
			}
		}
		public static int CompareCatType(this List<SbmTransactionPayment> values, SbmTransactionPayment transactionPayment1, SbmTransactionPayment transactionPayment)
		{
			if (transactionPayment1 == null || transactionPayment == null) return 0;
			if (transactionPayment1 == transactionPayment) return 0;

			// Compare the sequence derived from the typed code.
			if (transactionPayment1.CodeSeq > transactionPayment.CodeSeq) return 1;
			if (transactionPayment1.CodeSeq < transactionPayment.CodeSeq) return -1;

			// Code sequences are the same - compare the type code.
			if (transactionPayment1.Type != transactionPayment.Type)
				return transactionPayment1.Type.CompareTo(transactionPayment.Type);
			return -1;
		}
		public static void Sort(this List<SbmTransactionPayment> values)
		{
			values.Sort
				(
					delegate (SbmTransactionPayment transactionPayment1, SbmTransactionPayment transactionPayment2)
					{
						//return CompareCatType(values, -1, 0);
						return CompareCatType(values, transactionPayment1, transactionPayment2);
					}
				);
		}

		public static decimal GetAmountTotal(this List<SbmTransactionPayment> values)
		{
			decimal amountTotal = 0.0m;
			for (int pay = 1; pay <= values.Count; pay++)
			{
				SbmTransactionPayment transactionpayment = values[pay];
				amountTotal += transactionpayment.Amount;
			}
			return amountTotal;
		}
		//-------------------------------------------------------------------
		public static List<SbmTransactionPayment> Clone(this List<SbmTransactionPayment> values)
		{
			List<SbmTransactionPayment> transactionPayments = new List<SbmTransactionPayment>();
			// Clone each item in the list
			for (int pos = 1; pos <= values.Count; pos++)
				transactionPayments.Add(values[pos].Clone());
			return transactionPayments;
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
}