/*

* 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;

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();

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

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

                // input.

                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 KParamProgress = "-PROGRESS";

        #endregion

        #region Internal methods

        private bool CheckForProgressParameter()

        {

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

            return report;

        }

        private CISink FindSink()

        {

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

            CISink ret = null;

            //

            CISinkManager sinkManager = iCrashItemEngine.SinkManager;

            foreach ( CISink sink in sinkManager )

            {

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

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

                {

                    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" );

        }

        private void TryToPrimeDbgEngine()

        {

            DbgEngine debugEngine = iDebugEngine;

            //

            Exception primerException = null;

            CACmdLineFSEntityList<CACmdLineFSEntity> metaDataFiles = iInputs.MetaDataFiles;

            //

            try

            {

                debugEngine.Clear();

                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();

            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;

            // Emit progress banner

            if ( iReportProgress )

            {

                Print( "Creating CI content..." );

            }

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

            {

                CACmdLineFileSource file = sourceFileNames[ i ];

                System.Console.WriteLine("Starting to process file " +file.Name);

                // If the file has a corresponding source then we know that crash item recognised it.

                // Otherwise, we skip it.

                if ( file.Source != null )

                {

                    // We copy and remove all the file-level messages. These will be added to the container

                    // (where appropriate) or then to an output entry otherwise.

                    CACmdLineMessage[] fileMessages = file.ToArray();

                    file.Clear();

                    // At this point, the input file is guaranteed to have an associated container. In

                    // the current mobile crash file format, there will be a 1:1 mapping, i.e. each file

                    // will contain a single crash report ("container") and therefore if symbols were

                    // found for just a single container (within the file) then it's good enough to treat

                    // the file as archivable.

                    foreach ( CIContainer container in file.Containers )

                    {

                        // Firstly, add any meta-data errors/messages/warnings to this container

                        // as crash item message entries

                        AddMetaDataMessagesToContainer( container );

                        SetArchiveFileName(file.Name, container, sink);

                        foreach (CIMessage message in container.Messages)

                        {

                            if (message.Type == CrashItemLib.Crash.Messages.CIMessage.TType.ETypeError)

                            {

                                container.Status = CIContainer.TStatus.EStatusErrorContainer;

                            }

                        }

                        // Now we can try to serialize the container to CI. This method will

                        // not throw an exception.

                        //

                        // If the operation succeeds, then the input file will have an associated

                        // container object (and associated xml output file name) and we need not

                        // do anymore.

                        //

                        // If it fails, then the input file will not be assigned the container

                        // object and therefore, later on, we'll invoke the CI Sink directly to 

                        // create a stub 'FAILED' CI output file.

                        //

                        // NB: If Symbols were not available for the specified container, then

                        // we don't create a CI file but instead callback to a helper that

                        // will move the file to another temporary location for later repeat

                        // processing

                        bool hasSymbols = ContainsSymbols( container );

                        if (container.Status == CIContainer.TStatus.EStatusErrorContainer) //normally don't output containers with errors

                        {

                            file.State = CACmdLineFileSource.TState.EStateUninitialized;

                            if (iInputs.DecodeWithoutSymbols) //with force mode, output no matter what

                            {

                                TryToCreateOutput(sink, container, file, fileMessages);

                            }

                        }

                        else if (hasSymbols || IsSymbollessMobileCrash( container ))

                        {