/*

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

using CrashItemLib.Sink;

using CrashItemLib.Engine;

using CrashItemLib.Engine.Sources;

using CrashItemLib.PluginAPI;

using CrashAnalyserEngine.Engine;

using CrashAnalyserEngine.Plugins;

using CrashAnalyserEngine.Interfaces;

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 CAPCrashAnalysis.Plugin;

using CAPCrashAnalysis.CommandLine.Progress;

using SymbianDebugLib;

using SymbianDebugLib.Engine;

using SymbianDebugLib.Entity;

using SymbianUtils;

namespace CAPCrashAnalysis.CommandLine

{

	internal class CACmdLineEngine

	{

		#region Constructors

        public CACmdLineEngine( CAPluginCrashAnalysis aEngine )

		{

            iEngine = aEngine;

            iInputs = new CACmdLineInputParameters( aEngine );

		}

		#endregion

        #region API

        public bool IsCommandLineHandler( string aName )

        {

            bool ret = ( aName.ToUpper() == KPluginCommandLineName );

            return ret;

        }

        public int RunCommandLineOperations()

        {

            UITrace( "[CA Cmd] START " );

            UITrace( string.Empty );

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

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

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

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

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

            UITrace( string.Empty );

            int error = CAPlugin.KErrCommandLineNone;

            //

            try

            {

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

                string inputFileName = ExtractCommandLineInputParameter( CommandLineArguments );

                bool generateReport = CheckForReportParameter( CommandLineArguments );

                iProgressReporter.Enabled = CheckForProgressParameter( CommandLineArguments );

                iProgressReporter.Detailed = CheckForProgressDetailedParameter(CommandLineArguments);

                // If no file was found then inputFileName will be an empty string.

                if ( string.IsNullOrEmpty( inputFileName ) )

                {

                    throw new CACmdLineException( "Input file parameter missing", CAPlugin.KErrCommandLinePluginArgumentsMissing );

                }

                else if ( !FSUtilities.Exists( inputFileName ) )

                {

                    throw new CACmdLineException( "Input file not found", CAPlugin.KErrCommandLinePluginArgumentsFileNotFound );

                }

                else

                {

                    // Switch off UI output at the debug engine level

                    iEngine.DebugEngine.UiMode = TDbgUiMode.EUiDisabled;

                    // Reading the input file will throw an exception upon error.

                    // This is caught below and mapped onto an error code. There's nothing

                    // else we can do in this situation.

                    ReadInputFile( inputFileName );

                    // At this point we have enough information to identify the exact total

                    // number of progress reporting steps that will follow during the

                    // rest of the processing operation.

                    CalculateNumberOfOperationSteps();

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

                    // Now link the input files with crash source objects

                    AssociateInputFilesWithCrashItemSources();

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

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

                    // input.

                    //

                    // We don't need to do this for summary operations

                    if ( iInputs.SinkParameters.DetailLevel != CISinkSerializationParameters.TDetailLevel.ESummary )

                    {

                        TryToPrimeDbgEngine();

                    }

                    // Next we print out progress steps for skipped files, because those 

                    // files are count to total steps.

                    PrintOutSkippepFiles();

                    // 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' XML files.

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

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

                    TryToCreateXmlOutput();

                    // Finally, we want to create the XML manifest/report data, which we'll emit 

                    // via standard output.

                    if ( generateReport )

                    {

                        CreateAndEmitXmlReport();

                    }

                }

            }

            catch ( CACmdLineException cmdLineException )

            {

                error = cmdLineException.ErrorCode;

                //

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

            }

            catch ( Exception generalException )

            {

                error = CAPlugin.KErrCommandLineGeneral;

                //

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

            }

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

            return error;

        }

        #endregion

		#region Properties

        public string[] CommandLineArguments

        {

            get { return iEngine.UIEngine.CommandLineArguments; }

        }

        public CIEngine CrashItemEngine

        {

            get { return iEngine.CrashItemEngine; }

        }

        #endregion

        #region Event handlers

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

        {

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

            iProgressReporter.StepBegin("Priming debug meta-data: " + aEntity.FullName, aEntity.FullName, 100);

        }

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

        {

            if ( aContext != null )

            {

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

                {

                    int value = (int) aContext;

                    UITrace( "[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.

                    iProgressReporter.StepProgress(string.Empty, value, aEntity.FullName);

                }

            }

        }

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

        {

            iProgressReporter.StepEnd(string.Empty, aEntity.FullName);

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

        }

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

        {

            string msg = string.Empty;

            //

            switch ( aEvent )

            {

            case CIEngine.TSourceEvent.EEventSourceStateChanged:

                if ( aSource.State == CIEngineSource.TState.EStateProcessing )

                {

                    iProgressReporter.StepBegin("Processing crash file: " + aSource.FileName, aSource.FileName, 100);

                }

                break;

            case CIEngine.TSourceEvent.EEventSourceReady:

                iProgressReporter.StepEnd(string.Empty, aSource.FileName);

                break;

            case CIEngine.TSourceEvent.EEventSourceProgress:

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

                {

                    iProgressReporter.StepProgress(string.Empty, (int)aParameter, aSource.FileName);

                }

                break;

            default:

                break;

            }

        }

        #endregion

        #region Internal constants

        private const string KParamReport = "-REPORT";

        private const string KParamProgress = "-PROGRESS";

        private const string KParamProgressDetailed = "-PROGRESS_DETAILS";

        private const string KPluginCommandLineName = "CRASH_ANALYSIS";

        private const string KPluginInputParameter = "-INPUT";

        private const string KPluginInputFileDocumentRootNode = "crash_analysis";

        // Step keys for progress reporting

        private const string KStepKeyReadingInputXml = "READING_INPUT_XML";

        private const string KStepKeyPrimingSources = "PRIMING_SOURCES";

        private const string KStepKeyWritingOutputXml = "WRITING_OUTPUT_XML";

        private const string KStepKeyCategorizingInputFiles = "CATEGORIZING_INPUT_FILES";

        #endregion

        #region Internal methods

        private string ExtractCommandLineInputParameter( string[] aArgs )

        {

            string ret = string.Empty;

            // -nogui -plugin CRASH_ANALYSIS -input d:\ca_fullsummary.xml

            for( int i=0; i<aArgs.Length; i++ )

            {

                string cmd = aArgs[ i ].Trim().ToUpper();

                string nextArg = ( i < aArgs.Length - 1 ? aArgs[ i + 1 ].Trim().ToUpper() : string.Empty );

                //

                if ( cmd == KPluginInputParameter && nextArg != string.Empty )

                {

                    ret = nextArg;

                }

            }

            return ret;

        }

        private bool CheckForReportParameter( string[] aArgs )

        {

            bool report = false;

            //

            string[] args = aArgs;

            for ( int i = 0; i < args.Length; i++ )

            {

                string cmd = args[ i ].Trim().ToUpper();

                string nextArg = ( i < args.Length - 1 ? args[ i + 1 ].Trim().ToUpper() : string.Empty );

                //

                try

                {

                    if ( cmd == KParamReport )

                    {

                        UITrace( "[CA Cmd] XML report requested." );

                        report = true;

                        break;

                    }

                }

                catch ( Exception )

                {

                }

            }

            //

            return report;

        }

        private bool CheckForProgressParameter( string[] aArgs )

        {

            bool report = false;

            //

            string[] args = aArgs;

            for ( int i = 0; i < args.Length; i++ )

            {

                string cmd = args[ i ].Trim().ToUpper();

                string nextArg = ( i < args.Length - 1 ? args[ i + 1 ].Trim().ToUpper() : string.Empty );

                //

                try

                {

                    if ( cmd == KParamProgress )

                    {

                        UITrace( "[CA Cmd] progress requested." );

                        report = true;

                        break;

                    }

                }

                catch ( Exception )

                {

                }

            }

            //

            return report;

        }

        private bool CheckForProgressDetailedParameter(string[] aArgs)

        {

            bool report = false;

            //

            string[] args = aArgs;

            for (int i = 0; i < args.Length; i++)

            {

                string cmd = args[i].Trim().ToUpper();

                string nextArg = (i < args.Length - 1 ? args[i + 1].Trim().ToUpper() : string.Empty);

                //

                try

                {

                    if (cmd == KParamProgressDetailed)

                    {

                        UITrace("[CA Cmd] detailed progress requested.");

                        report = true;

                        break;

                    }

                }

                catch (Exception)

                {

                }

            }

            //

            return report;

        }

        private CISink FindXmlSink()

        {

            UITrace( "[CA Cmd] FindXmlSink() - START" );

            CISink ret = null;

            //

            CISinkManager sinkManager = iEngine.CrashItemEngine.SinkManager;

            foreach ( CISink sink in sinkManager )

            {

                UITrace( "[CA Cmd] FindXmlSink() - found sink: " + sink.Name );

                if ( sink.Name.ToUpper().Contains( "CRASH XML" ) )

                {

                    ret = sink;

                    break;

                }

            }

            //

            UITrace( "[CA Cmd] FindXmlSink() - END - ret: " + ret );

            return ret;

        }

        private void ReadInputFile( string aFileName )

        {

            UITrace( "[CA Cmd] ReadInputFile() - START - aFileName: " + aFileName );

            iProgressReporter.StepBegin( "Reading XML input file...", KStepKeyReadingInputXml );

            iInputs.Read( aFileName );

            iProgressReporter.PrintProgress( string.Format( "{0} META DATA FILES", iInputs.MetaDataFiles.Count ), 1 );

            iProgressReporter.PrintProgress( string.Format( "{0} CRASH FILES", iInputs.SourceFiles.Count ), 1 );

            iProgressReporter.StepEnd( "Read XML input file.", KStepKeyReadingInputXml );

            UITrace( "[CA Cmd] ReadInputFile() - END - read okay: " + aFileName );

        }

        private void CalculateNumberOfOperationSteps()

        {

            // We start at one, since reading the input file is the first step

            int totalStepCount = 1;

            // 2) Prime sources

            ++totalStepCount;

            // 3) Cross reference/associate sources with inputs

            ++totalStepCount;

            // 4) Debug meta data priming - one step for each debug meta data entity.

            if ( iInputs.SinkParameters.DetailLevel != CISinkSerializationParameters.TDetailLevel.ESummary )

            {

                totalStepCount += iInputs.MetaDataFiles.Count;

            }

            // 5) Reading source files - one step for each file

            totalStepCount += iInputs.SourceFiles.Count;

            // 6) Outputting XML - treated as one entire step, with sub-step progress reporting.

            // We can't do any better than this because the number of XML files depends on the number

            // of crash containers that are created when the files are read (step 5).

            ++totalStepCount;

            // All future operations will include an accurate step number prefix

            iProgressReporter.TotalNumberOfSteps = totalStepCount;

        }

        public void UITrace( string aMessage )

        {

            iEngine.UIManager.UITrace( aMessage );

        }

        public void UITrace( string aFormat, params object[] aParams )

        {

            string msg = string.Format( aFormat, aParams );

            UITrace( msg );

        }

        private void TryToPrimeSources()

        {

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

            CrashItemEngine.ClearAll();

            // Prime engine with source files

            CACmdLineFSEntityList<CACmdLineFileSource> sourceFileNames = iInputs.SourceFiles;

            int count = sourceFileNames.Count;

            // Emit progress banner

            iProgressReporter.StepBegin( "Locating crash files...", KStepKeyPrimingSources, count );

            skippedFiles.Clear();

            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.

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

                    bool primeSuccess = CrashItemEngine.Prime( file );

                    if ( primeSuccess == false )

                    {

                        skippedFiles.Add(file.Name);

                    }

                    UITrace( "[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 );

                }

                // Report progress as we work through the sources

                iProgressReporter.StepProgress(string.Empty, i, KStepKeyPrimingSources);

            }

            iProgressReporter.StepEnd( string.Empty, KStepKeyPrimingSources );

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

        }

        private void TryToPrimeDbgEngine()

        {

            DbgEngine debugEngine = iEngine.DebugEngine;

            //

            Exception primerException = null;

            CACmdLineFSEntityList<CACmdLineFSEntity> metaDataFiles = iInputs.MetaDataFiles;

            //

            try

            {

                debugEngine.Clear();

                foreach ( CACmdLineFSEntity entry in metaDataFiles )

                {

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

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

                    if ( entity != null )

                    {

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

                        entity.Tag = entry;

                    }

                    else

                    {

                        UITrace( "[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

                {

                    UITrace( "[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 );

                    UITrace( "[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 )

            {

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

                primerException = exception;

            }