/* name: FSM.cs
 * author: sam petro
 * created: 8 Feb 2007
 * last updated: 8 Feb 2007
 * 
 * description: the finite state machine (FSM) which will control
 *      the AI for the enemy ships
 * 
 */
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.Content;
using ToolshedGames.InfiniteVelocity.AI;

namespace ToolshedGames.InfiniteVelocity.AI
{
    public class FSM <entity>  //created 8 feb 2007
    {
        //--- PRIVATE DATA
        private entity pOwner; //a ref to the instance's owner
        private State<entity> pCurrentState; //a reference to the current state
        private State<entity> pPreviousState; //a reference to the previous state
        private State<entity> pGlobalState; //the global state called by the FSM

        //--- CONSTRUCTORS -------------------//
        /// <summary>
        /// constructor. initializes the current state,
        /// previous state, and glo
        /// </summary>
        /// <param name="owner">the owner of the FSM</param>
        public FSM(entity owner)
        {
            pOwner = owner;
            pCurrentState = null;
            pPreviousState = null;
            pGlobalState = null;
        }

        ~FSM() { } //destructor

        //--- FSM initializers ----------------------//
        /// <summary>
        /// Set the current state.
        /// used during initialization
        /// </summary>
        /// <param name="cs">current state of to the entity</param>
        public void SetCurrentState(State<entity> cs) { pCurrentState = cs; }

        /// <summary>
        /// set the global state
        /// used during initialization
        /// do not initialize if entity does not have a current state
        /// </summary>
        /// <param name="gs">global state of the entity</param>
        public void SetGlobalState(State<entity> gs) {pGlobalState = gs;}

        /// <summary>
        /// set the previous state
        /// possibly to be used in AI stack?
        /// </summary>
        /// <param name="ps">previous state of the entity</param>
        public void SetPreviousState(State<entity> ps) {pPreviousState = ps;}

        //--- GET states --------------// REVAMP IN C# STYLE???
        State<entity> CurrentState() { return pCurrentState; }
        State<entity> GlobalState() { return pGlobalState; }
        State<entity> PreviousState() { return pPreviousState; }

        //--- UPDATE ------------------//
        /// <summary>
        /// update the FSM. updates the owner's global
        /// then current states.
        /// </summary>
        public void Update()
        {
            //if there's a global state, execute it
            if (pGlobalState != null) pGlobalState.Execute(pOwner);
            //execute the current state too
            if (pCurrentState != null) pCurrentState.Execute(pOwner);
        }

        /* public bool HandleMessage(ref Telegram msg)
        {  //!!!!! CHECK VALIDITY OF STATEMENTS
         * // AND ADD DATESTAMP
            //check to see that the current state is valid
            //and can handle the message
            if (pCurrentState != null &&
                    pCurrentState.OnMessage(pOwner, msg))
                return true;
            
            //if not, check for global state, send message to
            //global state, if implemented
            if (pGlobalState != null && pGlobalState.OnMessage(pOwner, msg))
                return true;
         
            //if both checks fail
            return false;
        }*/

        //--- STATE CHANGES ---------------------------//
        /// <summary>
        /// transitions into the new state from the old
        /// stores old state, calls its exit function
        /// sets new state as current, calls enter function
        /// </summary>
        /// <param name="pNewState">new state to become current</param>
        public void ChangeState(State<entity> pNewState)
        {
            //assert and throw error? (see AI book code)

            //keep a record of previous state
            pPreviousState = pCurrentState; 

            //call the exit method
            pCurrentState.Exit(pOwner);

            //change state to new state
            pCurrentState = pNewState;

            //call the enter method of the new state
            pNewState.Enter(pOwner);
        }
        //POSSIBLE IMPLEMENTATION OF AI STACK???
        //perhaps a new stack function set????

        /// <summary>
        /// reverts to previous state
        /// useful for returning to global states
        /// </summary>
        public void RevertToPreviousState()
        {
            ChangeState(pPreviousState);
        }
    }
}