/*

* Copyright (c) 2009 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.Text;

using System.IO;

using System.Xml;

using System.Collections.Generic;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Container;

using CrashItemLib.Crash.Source;

using CrashItemLib.Crash.Processes;

using CrashItemLib.Crash.Messages;

using CrashItemLib.Crash.Summarisable;

using CrashItemLib.Sink;

using CrashItemLib.Engine;

using CrashItemLib.Engine.Sources;

using CrashItemLib.Engine.Interfaces;

using CrashItemLib.PluginAPI;

using SymbianUtils.FileSystem.Utilities;

using SymbianXmlInputLib.Parser;

using SymbianXmlInputLib.Parser.Nodes;

using SymbianXmlInputLib.Elements;

using SymbianXmlInputLib.Elements.Types.Category;

using SymbianXmlInputLib.Elements.Types.FileSystem;

using SymbianXmlInputLib.Elements.Types.Command;

using SymbianDebugLib;

using SymbianDebugLib.Engine;

using SymbianDebugLib.Entity;

using SymbianUtils;

using SymbianUtils.Tracer;

using CrashItemLib.Crash.InfoSW;

using MobileCrashLib;

using MobileCrashLib.Parser;

using MobileCrashLib.Structures.Items;

using MobileCrashLib.Structures;

namespace CrashAnalyserServerExe.Engine

{

    internal class CACmdLineEngine : DisposableObject, ITracer, ICIEngineUI

	{

		#region Constructors

        public CACmdLineEngine( DbgEngine aDebugEngine )

		{

            iDebugEngine = aDebugEngine;

            iInputs = new CACmdLineInputParameters( aDebugEngine );

            iCrashItemEngine = new CIEngine( aDebugEngine, this as ICIEngineUI );

		}

		#endregion

        #region API

        public int RunCommandLineOperations()

        {

            Trace( "[CA Cmd] START " );

            Trace( string.Empty );

            Trace( "[CA Cmd] command line: " + System.Environment.CommandLine );

            Trace( "[CA Cmd] command wd:   " + System.Environment.CurrentDirectory );

            Trace( "[CA Cmd] proc count:   " + System.Environment.ProcessorCount );

            Trace( "[CA Cmd] sysdir:       " + System.Environment.SystemDirectory );

            Trace( "[CA Cmd] version:      " + System.Environment.Version.ToString() );

            Trace( string.Empty );

            int error = CACmdLineException.KErrNone;

            //

            try

            {

                if (!iInputs.ParseCommandLine())

                {

                    throw new CACmdLineException("Error while parsing command line", CACmdLineException.KErrCommandLineError);

                }

                // We expect to see an "-input" parameter

                iReportProgress = CheckForProgressParameter();

                // Switch off UI output at the debug engine level

                iDebugEngine.UiMode = TDbgUiMode.EUiDisabled;

                // Next, attempt to prime the crash engine with every source we

                // identified from the input specification. The goal is to

                // create all the needed Crash Item Source objects for each input file.

                // Any inputs which we don't support will not have an associated source and

                // will be flagged accordingly within the CACmdLineFileSource object.

                TryToPrimeSources();

                // Try to the ROM ID and file type (i.e. crash, 

                // registration msg, report) out of the crash files. This information is

                // used in later phases (e.g. if there are only registration messages in 

                // source files then we do not have to load symbol files).

                TryToGetCrashInformation();

                // Next, prime the debug engine will all the debug meta-data inputs.

                // Again, individual error messages will be associated with each meta-data

                // input.

              //  if (SymbolFilesNeeded())

                {

                    TryToPrimeDbgEngine();

                }

                // Next, we invoke the crash engine to process all the crash item sources we

                // created during the prime step. Exceptions are caught and associated 

                // messages & diagnostics are created at the input-file level.

                TryToIdentifyCrashes();

                // Next, we start the output phase. Any 'valid' crash containers are serialized

                // to xml. Any input files which could not be processed have 'dummy' containers

                // created for them, and these are also serialised to 'failed' CI files.

                // If the CI Sink plugin is unavailable, then we cannot create any CI output.

                // In this situation, we throw an exception which is caught below.

                TryToCreateOutput();

            }

            catch ( CACmdLineException cmdLineException )

            {

                error = cmdLineException.ErrorCode;

                //

                Trace( "[CA Cmd] " + cmdLineException.Message + " " + cmdLineException.StackTrace );

            }

            catch ( Exception generalException )

            {

                error = CACmdLineException.KErrGeneral;

                //

                Trace( "[CA Cmd] " + generalException.Message + " " + generalException.StackTrace );

            }

            Trace( "[CA Cmd] - operation complete: " + error );

            return error;

        }

        #endregion

		#region Properties

        public string CommandLineArguments

        {

            get { return Environment.CommandLine; }

        }

        public CIEngine CrashItemEngine

        {

            get { return iCrashItemEngine; }

        }

        #endregion

        #region Event handlers

        private void DbgEngine_EntityPrimingStarted( DbgEngine aEngine, DbgEntity aEntity, object aContext )

        {

            Trace( "[CA Cmd] Priming debug meta-data: " + aEntity.FullName );

            // Emit progress banner

            if ( iReportProgress )

            {

                Print( "Reading debug meta-data..." );

            }

        }

        private void DbgEngine_EntityPrimingProgress( DbgEngine aEngine, DbgEntity aEntity, object aContext )

        {

            if ( aContext != null )

            {

                if ( aContext.GetType() == typeof( int ) )

                {

                    int value = (int) aContext;

                    Trace( "[CA Cmd] Priming debug meta-data progress: {0:d3}% {1}", value, aEntity.FullName );

                    // If reporting progress, then output something so the carbide extension is aware

                    // of what is going on in the background.

                    if ( iReportProgress )

                    {

                        string msg = string.Format( "{1:d3}%, {0}", aEntity.FullName, value );

                        Print( msg );

                    }

                }

            }

        }

        private void DbgEngine_EntityPrimingComplete( DbgEngine aEngine, DbgEntity aEntity, object aContext )

        {

            Trace( "[CA Cmd] Primed debug meta-data: " + aEntity.FullName );

        }

        private void CrashItemEngine_SourceObserver( CIEngine.TSourceEvent aEvent, CIEngineSource aSource, object aParameter )

        {

            if ( iReportProgress )

            {

                string msg = string.Empty;

                //

                switch ( aEvent )

                {

                case CIEngine.TSourceEvent.EEventSourceReady:

                    msg = string.Format( "Reading file: [{0}], progress: 100%", aSource.FileName );

                    break;

                case CIEngine.TSourceEvent.EEventSourceProgress:

                    if ( aParameter != null && aParameter is int )

                    {

                        msg = string.Format( "Reading file: [{0}], progress: {1:d3}%", aSource.FileName, (int) aParameter );

                    }

                    break;

                default:

                    break;

                }

                // Output a message only if we have one

                if ( string.IsNullOrEmpty( msg ) == false )

                {

                    Print( msg );

                }

            }

        }

        #endregion

        #region Internal constants

        private const string KCrashItemSinkName = "CRASH INFO FILE";

        private const string KXmlCrashItemSinkName = "XML CRASH FILE";

        private const string KParamProgress = "-PROGRESS";

        #endregion

        #region Internal methods

        private bool CheckForProgressParameter()

        {

            bool report = this.CommandLineArguments.Contains( KParamProgress );

            return report;

        }

        private CISink FindSink(bool aUseXmlSink)

        {

            Trace( "[CA Cmd] FindSink() - START" );

            CISink ret = null;

            //

            string sinkToUse = KCrashItemSinkName;

            if (aUseXmlSink)

            {

                sinkToUse = KXmlCrashItemSinkName;

            }

            CISinkManager sinkManager = iCrashItemEngine.SinkManager;

            foreach ( CISink sink in sinkManager )

            {

                Trace( "[CA Cmd] FindSink() - found sink: " + sink.Name );

                if ( sink.Name.ToUpper().Contains( sinkToUse ) )

                {

                    ret = sink;

                    break;

                }

            }

            //

            Trace( "[CA Cmd] FindSink() - END - ret: " + ret );

            return ret;

        }

        private void TryToPrimeSources()

        {

            Trace( "[CA Cmd] TryToPrimeSources() - START" );

            CrashItemEngine.ClearAll();

            // Prime engine with source files

            CACmdLineFSEntityList<CACmdLineFileSource> sourceFileNames = iInputs.SourceFiles;

            int progress = -1;

            int count = sourceFileNames.Count;

            // Emit progress banner

            if ( iReportProgress )

            {

                Print( "Locating crash files..." );

            }

            for ( int i = 0; i < count; i++ )

            {

                CACmdLineFileSource file = sourceFileNames[ i ];

                //

                try

                {

                    // We prime each file individually. If an exception is thrown then we

                    // record an appropriate error in the associated file object.

                    Trace( "[CA Cmd] TryToPrimeSources() - priming: " + file );

                    bool primeSuccess = CrashItemEngine.Prime( file );

                    // Report progress as we work through the sources

                    if ( iReportProgress )

                    {

                        float newProgress = ( ( (float) i + 1 ) / (float) count ) * 100.0f;

                        if ( (int) newProgress != progress || i == count - 1 )

                        {

                            progress = (int) newProgress;

                            Print( string.Format( "{0:d3}%", progress ) );

                        }

                    }

                    Trace( "[CA Cmd] TryToPrimeSources() - primed result: " + primeSuccess );

                }

                catch ( Exception sourcePrimerException )

                {

                    file.AddError( "Error Identifying Source Type", "There was an error when attempting to identify the source file type. The file could not be processed." );

                    file.AddDiagnostic( "Crash Primer Exception Message", sourcePrimerException.Message );

                    file.AddDiagnostic( "Crash Primer Exception Stack", sourcePrimerException.StackTrace );

                }

            }

            AssociateInputFilesWithCrashItemSources();

            Trace( "[CA Cmd] TryToPrimeSources() - END" );

        }

        /**

         * Get important data (i.e. RomId and content type)

         */

        private void TryToGetCrashInformation()

        {

            Trace("[CA Cmd] TryToGetCrashInformation() - START");

            foreach (CACmdLineFileSource file in iInputs.SourceFiles)

            {

                if (file.Source != null)

                {

                    byte[] bytes = File.ReadAllBytes(file.File.FullName);

                    MobileCrashBin bin = new MobileCrashBin(bytes);

                    MobileCrashData data = new MobileCrashData();

                    MobileCrashParser parser = new MobileCrashParser(bin, data);

                    parser.Parse(TSynchronicity.ESynchronous);

                    data = parser.MobileCrashData;

                    file.RomId = data.ItemById<MobileCrashItemUint32>(TMobileCrashId.EMobileCrashId_ROMID);

                    file.ContentType = data.ContentType;

                }

            }

            Trace("[CA Cmd] TryToGetCrashInformation() - END");

        }

        private void TryToPrimeDbgEngine()

        {

            DbgEngine debugEngine = iDebugEngine;

            //

            Exception primerException = null;

            CACmdLineFSEntityList<CACmdLineFSEntity> metaDataFiles = iInputs.MetaDataFiles;

            //

            try

            {

                debugEngine.Clear();

                foreach (CACmdLineFileSource file in iInputs.SourceFiles)

                {

                    if (file.RomId != null)

                        debugEngine.AddActiveRomId(file.RomId.Value);

                }

                foreach ( CACmdLineFSEntity entry in metaDataFiles )

                {

                    Trace( "[CA Cmd] Seeding debug meta engine with entry: " + entry.Name );

                    DbgEntity entity = debugEngine.Add( entry.Name );

                    if ( entity != null )

                    {

                        Trace( "[CA Cmd] Entry type detected as: [" + entity.CategoryName + "]" );

                        entity.Tag = entry;

                    }

                    else

                    {

                        Trace( "[CA Cmd] Entry not handled: " + entry.Name );

                        entry.AddError( "Meta-Data File Not Supported", "The file \'" + entry.Name + "\' is of unknown origin." );

                    }

                }

                // Listen to prime events

                try

                {

                    Trace( "[CA Cmd] Starting prime operation... " );

                    debugEngine.EntityPrimingStarted += new DbgEngine.EventHandler( DbgEngine_EntityPrimingStarted );

                    debugEngine.EntityPrimingProgress += new DbgEngine.EventHandler( DbgEngine_EntityPrimingProgress );

                    debugEngine.EntityPrimingComplete += new DbgEngine.EventHandler( DbgEngine_EntityPrimingComplete );

                    debugEngine.Prime( TSynchronicity.ESynchronous );

                    Trace( "[CA Cmd] Debug meta data priming completed successfully." );

                }

                finally

                {

                    debugEngine.EntityPrimingStarted -= new DbgEngine.EventHandler( DbgEngine_EntityPrimingStarted );

                    debugEngine.EntityPrimingProgress -= new DbgEngine.EventHandler( DbgEngine_EntityPrimingProgress );

                    debugEngine.EntityPrimingComplete -= new DbgEngine.EventHandler( DbgEngine_EntityPrimingComplete );

                }

            }

            catch ( Exception exception )

            {

                Trace( "[CA Cmd] Debug meta data priming exception: " + exception.Message + ", " + exception.StackTrace );

                primerException = exception;

            }

            // Go through each debug entity and check it for errors. Add diagnostics

            // and error messages where appropriate.

            foreach ( DbgEntity entity in debugEngine )

            {

                string name = entity.FullName;

                //

                CACmdLineFSEntity file = metaDataFiles[ name ];

                file.Clear();

                //

                if ( entity.PrimerResult.PrimedOkay )

                {

                    if ( !entity.Exists )

                    {

                        file.AddError( "Meta-Data File Missing", string.Format( "The file \'{0}\' could not be found.", file.Name ) );

                    }

                    else if ( entity.IsUnsupported )

                    {

                        file.AddError( "Meta-Data File Not Supported", string.Format( "The file \'{0}\' is of unknown origin.", file.Name ) );

                    }

                }

                else

                {

                    // Add error

                    file.AddError( "Meta-Data Read Error", entity.PrimerResult.PrimeErrorMessage );

                    // And diagnostic information

                    Exception exception = entity.PrimerResult.PrimeException != null ? entity.PrimerResult.PrimeException : primerException;

                    if ( exception != null )

                    {

                        file.AddDiagnostic( "Meta-Data Exception Message", entity.PrimerResult.PrimeException.Message );

                        file.AddDiagnostic( "Meta-Data Exception Stack", entity.PrimerResult.PrimeException.StackTrace );

                    }

                    else

                    {

                        file.AddDiagnostic( "Meta-Data Unknown Failure", "No exception occurred at the primer or entity level?" );

                    }

                }

            }

        }

        private void TryToIdentifyCrashes()

        {

            Exception crashEngineException = null;

            //

            try

            {

                iCrashItemEngine.SourceObservers += new CIEngine.CIEngineSourceObserver( CrashItemEngine_SourceObserver );

                iCrashItemEngine.IdentifyCrashes( TSynchronicity.ESynchronous );

            }

            catch ( Exception exception )

            {

                crashEngineException = exception;

            }

            finally

            {

                iCrashItemEngine.SourceObservers -= new CIEngine.CIEngineSourceObserver( CrashItemEngine_SourceObserver );

            }

            // Check each source in the engine and create messages based upon it's

            // state at the end of processing.

            foreach ( CACmdLineFileSource file in iInputs.SourceFiles )

            {

                if ( file.Source != null )

                {

                    CIEngineSource source = file.Source;

                    switch ( source.State )

                    {

                    case CIEngineSource.TState.EStateReady:

                        // Success case - the source resulted in the creation of at least one container

                        file.AddDiagnostic( "Source Read Successfully", string.Format( "{0} crash container(s) created", source.ContainerCount ) );

                        break;

                    case CIEngineSource.TState.EStateReadyNoItems:

                        file.AddWarning( "Source File Contains No Crashes", "The input data was read successfully but contains no crash information." );

                        break;

                    case CIEngineSource.TState.EStateReadyCorrupt:

                        file.AddError( "Source File is Corrupt", "The input data is invalid or corrupt." );

                        break;

                    case CIEngineSource.TState.EStateUninitialised:

                        file.AddError( "Source File not Read", "The input data was never read." );

                        file.AddDiagnostic( "Source State Invalid", "Source is still in unitialised state, even though reading is complete?" );

                        break;

                    case CIEngineSource.TState.EStateProcessing:

                        file.AddDiagnostic( "Source State Invalid", "Source is still in processing state, even though reading is complete?" );

                        break;

                    default:

                        break;

                    }

                }

                else

                {

                    file.AddError( "File is Not Supported", "There file type is not recognized and was not processed." );

                }

                // Add in details of any exception

                if ( crashEngineException != null )

                {

                    file.AddDiagnostic( "Crash Identification Exception Message", crashEngineException.Message );

                    file.AddDiagnostic( "Crash Identification Exception Stack", crashEngineException.StackTrace );

                }

            }

        }

        private void TryToCreateOutput()

        {

            CACmdLineFSEntityList<CACmdLineFileSource> inputFiles = iInputs.SourceFiles;

            //

            CISink sink = FindSink(iInputs.UseXmlSink);

            if ( sink == null )

            {

                throw new CACmdLineException( "CI Output Plugin Not Available", CACmdLineException.KErrSinkNotAvailable );

            }

            CACmdLineFSEntityList<CACmdLineFileSource> sourceFileNames = iInputs.SourceFiles;

            int progress = -1;

            int count = sourceFileNames.Count;