using System;
using System.Collections.Generic;
using System.Linq;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.Net.Standard.Base.Bus
{
	//=======================================================================
	//[Serializable()]
	public class SysId
	{
		//-------------------------------------------------------------------
		// Data members.
		private int id = 0;
		
		//-------------------------------------------------------------------
		// Construction.
		public SysId () { }
		public SysId (int id)
		{
			this.id = id;
		}

		//-------------------------------------------------------------------
		// Properties - for serialisation.
		//[XmlAttribute]
		public int Id
		{
			get { return id; }
			set
			{
				if (id != 0 && value != 0 && value != id) throw new NotSupportedException("SysId value cannot be changed once valid");
				id = value;
			}
		}

		//-------------------------------------------------------------------
		// Utilities.
		public static bool IsValid (SysId sysId)
		{
			return (sysId != null && sysId.id != 0);
		}
		public static SysId InvalidOnNull (SysId sysId)
		{
			return (sysId != null ? sysId : new SysId());
		}

		//-------------------------------------------------------------------
		// Comparison.
		public override bool Equals (object obj)
		{
			if (obj == null) return false;
			return Equals(obj as SysId);
		}
		public bool Equals (SysId sysId)
		{
			if (sysId == null) return false;
			// False if either value invalid.
			if (id == 0) return false;
			return ToInt().Equals(InvalidOnNull(sysId).ToInt());
		}
		public override int GetHashCode ()
		{
			return id;
		}

		//-------------------------------------------------------------------
		// Conversion.
		public int ToInt ()
		{
			return ToInt(this);
		}
		public override String ToString ()
		{
			return ToString(this);
		}
		public String ToString (String invalidValue)
		{
			return ToString(this, invalidValue);
		}
		// Null-safe static versions.
		public static int ToInt (SysId sysId)
		{
			return (IsValid(sysId) ? sysId.id : 0);
		}
		public static String ToString (SysId sysId)
		{
			return ToString(sysId, String.Empty);
		}
		public static String ToString (SysId sysId, String invalidValue)
		{
			return (IsValid(sysId) ? sysId.id.ToString() : invalidValue);
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
	public static class SysIdList
	{
		//-------------------------------------------------------------------
		// List contents.
		public static int GetIdCount (this List<SysId> values, bool ignoreInvalid = true, bool ignoreDuplicates = true)
		{
			if (ignoreDuplicates)
			{
				values = values.Select(id => id).Distinct().ToList();
				// SysId.Equals treats invalid ids as inequal so 'Distinct' doesn't remove them.
				if (values.FindIndex(id => !SysId.IsValid(id))  >= 0)
				{
					// Remove all invalid entries and put one back to correct the count.
					values.RemoveAll(id => !SysId.IsValid(id));
					values.Add(new SysId());
				}
			}
			return values.Count(id => !ignoreInvalid || SysId.IsValid(id));
		}
		public static bool HasValidIds (this List<SysId> values)
		{
			return (values.Find(id => SysId.IsValid(id)) != null);
		}
		public static bool Equals (this List<SysId> values, List<SysId> values2)
		{
			return values.OrderBy(id => id.Id).SequenceEqual(values2.OrderBy(id => id.Id));
		}

		//-------------------------------------------------------------------
		// Populate list.
		public static void AddId (this List<SysId> values, SysId sysId, bool ignoreInvalid = true, bool ignoreDuplicates = true)
		{
			if (ignoreInvalid && !SysId.IsValid(sysId)) return;
			if (ignoreDuplicates && values.Contains(sysId)) return;
			values.Add(sysId);
		}
		public static void AddIds (this List<SysId> values, List<SysId> sysIds, bool ignoreInvalid = true, bool ignoreDuplicates = true)
		{
			foreach (SysId id in sysIds)
				values.AddId(id, ignoreInvalid, ignoreDuplicates);
		}

		//-------------------------------------------------------------------
		// Extract from list.
		/// <summary>Remove specified number of entries from the list and return them.</summary>
		/// <returns></returns>
		public static List<SysId> ExtractIds (this List<SysId> values, int numberToRemove)
		{
			List<SysId> ids = new List<SysId>();
			while (values.Count > 0 && ids.Count < numberToRemove)
			{
				SysId id = values.ElementAt(0);
				values.RemoveAt(0);
				ids.Add(id);
			}
			return ids;
		}

		//-------------------------------------------------------------------
		/// <summary>
		/// Combine items in list as a delimited string.
		/// </summary>
		/// <param name="values"></param>
		/// <param name="delimiter"></param>
		/// <param name="ignoreInvalid"></param>
		/// <returns></returns>
		public static String Concat (this List<SysId> values, String delimiter, bool ignoreInvalid = true)
		{
			List<String> ids = new List<string>();
			foreach (SysId id in values.FindAll(id => !ignoreInvalid || SysId.IsValid(id)))
				ids.Add(id.ToString());
			return ids.Concat(delimiter);
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}