Having fun with custom collections!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TheCult
{
	/// <summary>
	/// A Class representing an organised cult. Each person that enters gets a mark and becomes a cultist.
	/// The organised cult has some sort of politics system allowing some 'favoured people' to enter and get a
	/// high rank right away. This cult also allows replacing of 'bad elements'.
	/// </summary>
	public class OrganisedCult : Cult, IList<Person>
	{

		/// <summary>
		/// Instantiates a new organised cult with no members.
		/// </summary>
		public OrganisedCult()
			: base()
		{
		}

		/// <summary>
		/// Instantiates a new organised cult with members.
		/// </summary>
		/// <param name="people">The people that will join the cult.</param>
		public OrganisedCult(IEnumerable<Person> people)
			: base(people)
		{
		}

		/// <summary>
		/// Searches for the specified person and returns the zero-based index of the first occurrence within the entire cult.
		/// </summary>
		/// <param name="item">The person to locate in the cult. The value can be null for reference types.</param>
		/// <returns>The zero-based index of the first occurrence of the person within the entire cult, if found; otherwise, –1.</returns>
		public int IndexOf(Person item)
		{
			Cultist cultist = base.InnerList.Where(c => c.FullName == item.FullName).FirstOrDefault();
			return base.InnerList.IndexOf(cultist);
		}

		/// <summary>
		/// Checks if a person is eligible to join the cult.
		/// </summary>
		/// <param name="person">The person to check.</param>
		/// <returns>True if a person can join the cult.</returns>
		protected override bool CanJoin(Person person)
		{
			// A person must have a minimum age of 18.
			return base.CanJoin(person) && person.Age >= 18;
		}

		/// <summary>
		/// Inserts a person into the cult at the specified index. This person will get a rank suitable for someone at his position.
		/// All people that are in the cult and have a rank lower than the just inserted person will move down a rank if applicable.
		/// </summary>
		/// <param name="index">The zero-based index at which the person should be inserted.</param>
		/// <param name="item">The person to insert.</param>
		public void Insert(int index, Person item)
		{
			if (item == null)
				throw new ArgumentNullException("Item cannot be nothing.");

			// First check if the person can join.

			if (base.CanJoin(item))
			{
				// Create a cultist and insert it to the inner list.
				Cultist cultist = Cultist.CreateCultist(item, base.GetMark());
				base.InnerList.Insert(index, cultist);

				if (index < 2)
				{
					// If the just inserted person has an index lower than two (someone must like him or this is a hostile takeover!)
					// he is either leader or general. Reset the first three ranks in the inner list.
					base.InnerList[0].Rank = CultRanks.Leader;
					base.InnerList[1].Rank = CultRanks.General;
					base.InnerList[2].Rank = CultRanks.Captain;
				}
				else if (base.InnerList[index + 1] != null && base.InnerList[index + 1].Rank == CultRanks.Captain)
				{
					// If the person above the just inserted person is a captain then the just inserted cultist
					// automatically becomes a captain too.
					cultist.Rank = CultRanks.Captain;
				}
				else
				{
					// If none of the above the just inserted person simply becomes a soldier.
					cultist.Rank = CultRanks.Soldier;
				}

				base.AssignNextCaptainIfNecessary();

			}
		}

		/// <summary>
		/// Gets or sets the item at the specified index.
		/// </summary>
		/// <param name="index">The zero-based index of the person to get or set.</param>
		public Person this[int index]
		{
			get { return base.InnerList[index]; }
			set
			{
				// Cannot use the MyBase.InnerList.Contains, because it contains cultists, not persons.
				if (!this.Contains(value) && this.CanJoin(value))
				{
					// Create a new cultist and replace the old cultist with the new one.
					Cultist cultist = Cultist.CreateCultist(value, base.GetMark());
					cultist.Rank = base.InnerList[index].Rank;
					base.InnerList[index].Rank = CultRanks.None;
					base.InnerList[index] = cultist;
				}
			}
		}

		/// <summary>
		/// Removes the person at the specified index from the cult. New ranks will be assigned as necessary.
		/// </summary>
		/// <param name="index">The zero-based index of the person to remove.</param>
		/// <remarks></remarks>
		public void RemoveAt(int index)
		{
			// Call the MyBase.Remove with the person at the specified index of the inner list.
			// The MyBase.Remove handles recalculations for ranks etc.
			base.Remove(base.InnerList[index]);
		}

	}
}