//Define the Element Base Class and Associated Child Clases.

//Define the Element class which contains all the core functions to be used in this pattern.
//All other classes will derive from this class.

//The input data to this class is provided by the Context class, and is declared in a predefined grammatical syntax.
//The Parse() and ParseNumber() methods work on the input data to generate an object structure of objects derived from the Element class (object).
//These include Lab, Test, MidTerm and Exam objects.
//Once the input data has been organised into the object structure, we can execute "interpreter" methods against the data to generate any outputs required.
//The ParseResults() method calculates ("interprets") student course results based on predefined weighting for each element of the course.
public class Element
{
public int Weight { get; set; }
public byte Level { get; set; }
public Element Next { get; set; }
public Element Child { get; set; }
public static int SumLab { get; set; }
public static int SumTest { get; set; }

public static int[] MValues;
public static int MCounter;
private static byte _mLevel = 1;

public virtual string Display()
{
return (string.Concat(Weight, "%"));
}

public void OutputResults(Context context, int[] values)
{
context.Output = 0;
MValues = values;
MCounter = 0;
ParseResults(context);
}

public void Print()
{
switch (Level)
{
case 0:
Console.WriteLine("{0}", this);
break;
case 1:
Console.WriteLine("\t{0} {1}", this, Weight);
break;
case 2:
Console.WriteLine("\t\t{0} {1}", this, Weight);
break;
}

if (Child != null)
{
Child.Next.Print();
}

if (Next != null)
{
Next.Print();
}
}

public void Summarize()
{
if (GetType() == typeof(Lab))
{
SumLab += Weight;
}
else if (GetType() == typeof(Test))
{
SumTest += Weight;
}
else if ((GetType() == typeof(MidTerm) || GetType() == typeof(Exam)) && Child == null)
{
SumTest += Weight;
}

if (Child != null)
{
Child.Next.Summarize();
}

if (Next != null)
{
Next.Summarize();
}
}

public void Parse(Context context)
{
string validInput = "LTME";
char element = char.MinValue;

if (context.Input.Length > 0)
{
if (validInput.IndexOf(context.Input[0]) >= 0)
{
element = context.Input[0];
}
}

if (element != char.MinValue)
{
switch (element)
{
case 'L':
Next = new Lab();
break;
case 'T':
Next = new Test();
break;
case 'M':
Next = new MidTerm();
break;
case 'E':
Next = new Exam();
break;
}

Next.Weight = ParseNumber(context);
Next.Level = _mLevel;

if (context.Input.Length > 0)
{
element = context.Input[0];
}

if (element == '(')
{
context.Input = context.Input.Substring(1);
Next.Child = new Element();
_mLevel++;
Next.Child.Parse(context);
_mLevel--;
Element e = Next.Child;

while (e != null)
{
e.Weight = e.Weight * Next.Weight / 100;
e = e.Next;
}

if (context.Input.Length >= 2)
{
context.Input = context.Input.Substring(2);
}
else
{
context.Input = context.Input.Substring(1);
}
}
else
{
Next.Child = null;
}

Next.Parse(context);
}

private int ParseNumber(Context context)
{
int posX = context.Input.IndexOf('|');
int value = int.Parse(context.Input.Substring(1, posX - 1)); context.Input = context.Input.Substring(posX + 1);

return value;
}

private void ParseResults(Context context)
{
if (GetType() == typeof(Lab) || GetType() == typeof(Test))
{
context.Output += MValues[MCounter] * Weight;
MCounter++;
}
else if ((this is MidTerm || this is Exam) && Child == null)
{
context.Output += MValues[MCounter] * Weight;
MCounter++;
}

if (Child != null)
{
Child.ParseResults(context);
}

if (Next != null)
{
Next.ParseResults(context);
}
}
}

//The Course class (object) represents the first element in the object structure.
//This class inherits from the Element class, and therefore inherits all the methods defined in the Element class.
public class Course : Element
{
public string Name { get; set; }

public Course(Context context)
{
Name = context.Input.Substring(0, 6);
context.Input = context.Input.Substring(7);
}

public override string Display()
{
return Name;
}

public override string ToString()
{
return "Course";
}
}

//The Lab class (object) represents another element in the object structure.
//This class inherits from the Element class, and therefore inherits all the methods defined in the Element class.
public class Lab : Element
{
public override string ToString()
{
return "Lab";
}
}

//The Test class (object) represents another element in the object structure.
//This class inherits from the Element class, and therefore inherits all the methods defined in the Element class.
public class Test : Element
{
public override string ToString()
{
return "Test";
}
}

//The MidTerm class (object) represents another element in the object structure.
//This class inherits from the Element class, and therefore inherits all the methods defined in the Element class.
public class MidTerm : Element
{
public override string ToString()
{
return "MidTerm";
}
}

//The Exam class (object) represents another element in the object structure.
//This class inherits from the Element class, and therefore inherits all the methods defined in the Element class.
public class Exam : Element
{
public override string ToString()
{
return "Exam";
}
}