/*
* Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using SymbianParserLib.Engine;
using CrashDebuggerLib.Structures.Fault;
using SymbianParserLib.Elements;
using CrashDebuggerLib.Parsers.State.Implementation;

namespace CrashDebuggerLib.Parsers.State
{
    internal static class StateFactory
    {
        #region API
        public static State Create( TState aState, CrashDebuggerParser aParser )
        {
            CreateDictionary();
            //
            State ret = null;
            if ( iDictionary.ContainsKey( aState ) )
            {
                ret = CreateState( aState, aParser );
                if ( ret != null )
                {
                    ret.Prepare();
                }
            }
            //
            return ret;
        }

        public static void RegisterCommands( ParserEngine aEngine )
        {
            CreateDictionary();
            //
            foreach ( KeyValuePair<TState, TStateMapplet> keyVP in iDictionary )
            {
                string[] commandIds = keyVP.Value.CommandIdentifiers;
                foreach ( string commandId in commandIds )
                {
                    // Create paragraph and associate the state type with the tag so that
                    // we know what type of object to create later on when the line fires.
                    ParserParagraph command = new ParserParagraph( commandId );
                    command.Tag = keyVP.Key;

                    // Create line to match
                    ParserLine line = ParserLine.New( commandId );

                    // Make sure that the paragraph and line don't disable themselves whenever
                    // they see a matching line. Some of these objects are needed more than once!
                    command.DisableWhenComplete = false;
                    line.DisableWhenComplete = false;
                    //
                    command.Add( line );
                    aEngine.Add( command );
                }
            }
        }
        #endregion

        #region Properties
        #endregion

        #region Internal methods
        private static void CreateDictionary()
        {
            if ( iDictionary.Count == 0 )
            {
                // State table
                iDictionary.Add( TState.EStateInfoFault, 
                                 new TStateMapplet( "*** CMD: Fault_Info", typeof( StateInfoFault ) ) );
                iDictionary.Add( TState.EStateInfoCpu, 
                                 new TStateMapplet( "*** CMD: Cpu_Info", typeof( StateInfoCpu ) ) );
                iDictionary.Add( TState.EStateInfoDebugMask,
                                 new TStateMapplet( "*** CMD: Debug_Mask_Info", typeof( StateInfoDebugMask ) ) );
                iDictionary.Add( TState.EStateInfoScheduler, 
                                 new TStateMapplet( "*** CMD: Scheduler_Info", typeof( StateInfoScheduler ) ) );

                // For compatibility reasons catch either of these entries
                iDictionary.Add( TState.EStateInfoUserContextTable,
                                 new TStateMapplet( typeof( StateInfoUserContextTable ),
                                                    "*** CMD: UserContextTable_Info",
                                                    "*** CMD: UserContextTables" ) );

                // Other entries...
                iDictionary.Add( TState.EStateTheCurrentProcess,
                                 new TStateMapplet( "*** CMD: The_Current_Process", typeof( StateTheCurrentProcess ) ) );
                iDictionary.Add( TState.EStateTheCurrentThread,
                                 new TStateMapplet( "*** CMD: The_Current_Thread", typeof( StateTheCurrentThread ) ) );
                iDictionary.Add( TState.EStateContainerCodeSegs,
                                 new TStateMapplet( "*** CMD: container[CODESEG]", typeof( StateContainerCodeSegs ) ) );
                iDictionary.Add( TState.EStateContainerThread,
                                 new TStateMapplet( "*** CMD: container[THREAD]", typeof( StateContainerThreads ) ) );
                iDictionary.Add( TState.EStateContainerProcess,
                                 new TStateMapplet( "*** CMD: container[PROCESS]", typeof( StateContainerProcesses ) ) );
                iDictionary.Add( TState.EStateContainerChunk,
                                 new TStateMapplet( "*** CMD: container[CHUNK]", typeof( StateContainerChunks ) ) );
                iDictionary.Add( TState.EStateContainerLibrary,
                                 new TStateMapplet( "*** CMD: container[LIBRARY]", typeof( StateContainerLibraries ) ) );
                iDictionary.Add( TState.EStateContainerSemaphore,
                                 new TStateMapplet( "*** CMD: container[SEMAPHORE]", typeof( StateContainerSemaphores ) ) );
                iDictionary.Add( TState.EStateContainerMutex,
                                 new TStateMapplet( "*** CMD: container[MUTEX]", typeof( StateContainerMutexes ) ) );
                iDictionary.Add( TState.EStateContainerTimer,
                                 new TStateMapplet( "*** CMD: container[TIMER]", typeof( StateContainerTimers ) ) );
                iDictionary.Add( TState.EStateContainerServer,
                                 new TStateMapplet( "*** CMD: container[SERVER]", typeof( StateContainerServers ) ) );
                iDictionary.Add( TState.EStateContainerSession,
                                 new TStateMapplet( "*** CMD: container[SESSION]", typeof( StateContainerSessions ) ) );
                iDictionary.Add( TState.EStateContainerLogicalDevice,
                                 new TStateMapplet( "*** CMD: container[LOGICAL DEVICE]", typeof( StateContainerLogicalDevices ) ) );
                iDictionary.Add( TState.EStateContainerPhysicalDevice,
                                 new TStateMapplet( "*** CMD: container[PHYSICAL DEVICE]", typeof( StateContainerPhysicalDevices ) ) );
                iDictionary.Add( TState.EStateContainerLogicalChannel,
                                 new TStateMapplet( "*** CMD: container[LOGICAL CHANNEL]", typeof( StateContainerLogicalChannels ) ) );
                iDictionary.Add( TState.EStateContainerChangeNotifier,
                                 new TStateMapplet( "*** CMD: container[CHANGE NOTIFIER]", typeof( StateContainerChangeNotifiers ) ) );
                iDictionary.Add( TState.EStateContainerUndertaker,
                                 new TStateMapplet( "*** CMD: container[UNDERTAKER]", typeof( StateContainerUndertakers ) ) );
                iDictionary.Add( TState.EStateContainerMessageQueue,
                                 new TStateMapplet( "*** CMD: container[MESSAGE QUEUE]", typeof( StateContainerMessageQueues ) ) );
                iDictionary.Add( TState.EStateContainerPropertyRef,
                                 new TStateMapplet( "*** CMD: container[PROPERTY REF]", typeof( StateContainerPropertyRefs ) ) );
                iDictionary.Add( TState.EStateContainerConditionalVariable,
                                 new TStateMapplet( "*** CMD: container[CONDITION VARIABLE]", typeof( StateContainerConditionalVariables ) ) );
                iDictionary.Add( TState.EStateThreadStacks,
                                 new TStateMapplet( "*** CMD: Stack_Data[", typeof( StateThreadStacks ) ) );
            }
        }

        private static State CreateState( TState aState, CrashDebuggerParser aParser )
        {
            TStateMapplet maplet = iDictionary[ aState ];
            State ret = maplet.CreateInstance( aParser );
            return ret;
        }
        #endregion

        #region Data members
        private static Dictionary<TState, TStateMapplet> iDictionary = new Dictionary<TState, TStateMapplet>();
        #endregion
    }

    #region Internal structure
    internal class TStateMapplet
    {
        #region Constructors
        public TStateMapplet( Type aType, params string[] aCommandIdentifiers )
        {
            iCommandIdentifiers = aCommandIdentifiers;
            iType = aType;
        }

        public TStateMapplet( string aCommandIdentifier, Type aType )
        {
            iCommandIdentifiers = new string[] { aCommandIdentifier };
            iType = aType;
        }
        #endregion

        #region API
        public State CreateInstance( CrashDebuggerParser aParser )
        {
            State state = null;
            //
            Binder binder = null;
            BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.CreateInstance;
            object[] args = { aParser };
            object ret = iType.InvokeMember( string.Empty, bindingFlags, binder, null, args );
            if ( ret != null )
            {
                state = (State) ret;
            }
            //
            return state;
        }
        #endregion

        #region Properties
        public string[] CommandIdentifiers
        {
            get { return iCommandIdentifiers; }
        }
        #endregion

        #region Data members
        private readonly string[] iCommandIdentifiers;
        private readonly Type iType;
        #endregion
    }
    #endregion
}