#pragma once

#pragma push_macro("new")
#undef new

__gc class Programmer : public IComparable
{
public:
	Programmer(String* fullName, int experienceInYears, int annualSalary)
	{
		this->fullName = fullName;
		this->experienceInYears = experienceInYears;
		this->annualSalary = annualSalary;
	}

protected:
	String* fullName;
	Int32 experienceInYears;
	Int32 annualSalary;
	
public:
	__property String* get_FullName() { return this->fullName; }
  __property Int32 get_ExperienceInYears() { return this->experienceInYears; }
  __property Int32 get_AnnualSalary() { return this->annualSalary; }

public:
	int CompareTo(Object* obj)
	{
		Programmer* tmp = dynamic_cast<Programmer*>(obj);
		return(fullName->CompareTo(tmp->fullName));
	}

	__gc class ProgrammerSalaryComparer : public IComparer
	{
	public:
		int Compare(Object* o1, Object* o2)
		{
		  Programmer* p1 = dynamic_cast<Programmer*>(o1);
		  Int32 p1Salary = p1->annualSalary;

		  Programmer* p2 = dynamic_cast<Programmer*>(o2);
		  Int32 p2Salary = p2->annualSalary;

			return -1 * p1Salary.CompareTo(__box(p2Salary));
		}
	};

	__gc class ProgrammerExperienceComparer : public IComparer
	{
	public:
		int Compare(Object* o1, Object* o2)
		{
		  Programmer* p1 = dynamic_cast<Programmer*>(o1);
		  Int32 p1Experience = p1->experienceInYears;

		  Programmer* p2 = dynamic_cast<Programmer*>(o2);
		  Int32 p2Experience = p2->experienceInYears;

			return -1 * p1Experience.CompareTo(__box(p2Experience));
		}
	};
};

__value enum ProgrammerSortOption
{
  ByName,
  ByExperience,
  BySalary
};

__gc class ProgrammerCollection : public IEnumerable
{
protected:
  ArrayList* programmers;
  bool dirty;

public:
  ProgrammerCollection()
  {
    programmers = new ArrayList();
    dirty = false;
  }

  __gc class ProgrammerEnumerator : public IEnumerator
  {
  public:
    ProgrammerEnumerator(ProgrammerCollection* collection)
    {
      this->collection = collection;
      position = -1;
    }
  protected:
    int position;
    ProgrammerCollection* collection;

  public:
    __property Object* get_Current()
    {
      if (0 > position
      || position >= collection->programmers->Count 
      || collection->dirty)
        throw new InvalidOperationException();
      
      return collection->programmers->Item[position];
    }

    void Reset()
    {
      collection->dirty = false;
      position = -1;
    }

    bool MoveNext()
    {
      if (collection->dirty)
        throw new InvalidOperationException();
        
      position++;

      return (position < collection->programmers->Count);
    }
  };

public:
	IEnumerator* GetEnumerator()
  {
    dirty = false;
    return dynamic_cast<IEnumerator*>(new ProgrammerEnumerator(this));
  }

  int Add(Object* value)
  {
    dirty = true;
    return programmers->Add(value);
  }

protected:
  ProgrammerSortOption sortOption;
public:
  void Sort(enum ProgrammerSortOption sortOption)
  {
    this->sortOption = sortOption;
    dirty = true;
    switch(sortOption)
    {
      case ProgrammerSortOption::ByName:
        programmers->Sort();
        break;
      case ProgrammerSortOption::ByExperience:
        programmers->Sort(new Programmer::ProgrammerExperienceComparer);
        break;
      case ProgrammerSortOption::BySalary:
        programmers->Sort(new Programmer::ProgrammerSalaryComparer);
        break;
      default: 
        ASSERT(FALSE);
        break;
    }
  }

public:  
  int IndexOf(Programmer* programmer)
  {
    Sort(this->sortOption);
    return programmers->IndexOf(programmer);
  }
};

#pragma pop_macro("new")