/*
 * GenericPhaseQueue.cs
 * Authors:     August Zinsser, Sriharsha Matta
 * 
 * Copyright Matthew Belmonte 2007
 */


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

namespace tAC_Engine
{
    /// <summary>
    /// All phases that a minigame may use
    /// </summary>
    public abstract class GenericPhases
    {
        protected static List<string> mList = new List<string>();

        /// <summary>
        /// mList must be defined within this body for each specific class due to the fact that C# does not support function overloading
        /// </summary>
        /// <param name="phaseName"></param>
        /// <returns></returns>
        public abstract bool Contains(string phaseName);
    }  


    /// <summary>
    /// Used to hold the order of phases
    /// </summary>
    public class GenericTest
    {
        public string PhaseName;                    // Name of this test
        public int Trials;                          // Trials for this test
        public List<string> SpecificParameters;     // Parsed by specific minigames

        protected GenericPhases mPhases = null;     // Must be assigned to a specific phase set in each derived class


        /// <summary>
        /// Assign all generic variables and store specific variables as strings to be decoded by derivatives of this class
        /// </summary>
        /// <param name="phaseName">Name of this test</param>
        /// <param name="trials">Number of trials for this test</param>
        /// <param name="specificParameters">Parameters passed to a specific test that inherits from this generic template</param>
        public GenericTest(string phaseName, int trials, List<string> specificParameters)
        {
            PhaseName = phaseName;
            Trials = trials;
            SpecificParameters = specificParameters;
            if (SpecificParameters == null)
                SpecificParameters = new List<string>();
        }
    }


    /// <summary>
    /// Provides a template for minigames with phases to control the phase flow
    /// </summary>
    public class GenericPhaseQueue
    {
        protected Queue<GenericTest> mTestQueue;  // Holds all trials for the minigame

        public int Count { get { return mTestQueue.Count; } }


        /// <summary>
        /// Default constructor
        /// </summary>
        public GenericPhaseQueue()
        {
            mTestQueue = new Queue<GenericTest>();
        }


        /// <summary>
        /// Copy constructor
        /// </summary>
        public GenericPhaseQueue(GenericPhaseQueue pq)
        {
            mTestQueue = new Queue<GenericTest>();

            GenericTest[] testArray = new GenericTest[pq.mTestQueue.Count];
            
            pq.mTestQueue.CopyTo(testArray, 0);
            
            for (int i = 0; i < pq.mTestQueue.Count; i++)
            {
                mTestQueue.Enqueue(testArray[i]);
            }


        }


        /// <summary>
        /// Add a testing phase
        /// </summary>
        /// <param name="testPhase"></param>
        public void Enqueue(GenericTest testPhase)
        {
            mTestQueue.Enqueue(testPhase);
        }


        /// <summary>
        /// Removes the oldest testing phase from the list and returns it
        /// </summary>
        /// <returns></returns>
        public GenericTest Dequeue()
        {
            return mTestQueue.Dequeue();
        }
    }
}