/*
* 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.Collections.Generic;
using CrashAnalyserEngine.Plugins;
using CrashItemLib.Engine;
using CrashItemLib.Crash;
using CrashItemLib.Crash.Container;
using CrashItemLib.PluginAPI;
using CrashAnalyserEngine.Engine;
using CrashAnalyserEngine.Interfaces;
using CAPCrashAnalysis.Plugin;
using SymbianUtils.FileSystem.Utilities;
using SymbianXmlInputLib.Parser;
using SymbianXmlInputLib.Parser.Nodes;
using SymbianXmlInputLib.Elements;
using SymbianXmlInputLib.Elements.Types.Category;
using SymbianXmlInputLib.Elements.Types.Extension;
using SymbianXmlInputLib.Elements.Types.FileSystem;
using SymbianXmlInputLib.Elements.Types.Command;
using CrashItemLib.Sink;

namespace CAPCrashAnalysis.CommandLine
{
	internal class CACmdLineInputParameters
	{
		#region Constructors
        public CACmdLineInputParameters( CAPluginCrashAnalysis aEngine )
		{
            iEngine = aEngine;
            //
            Version version = aEngine.UIManager.UIVersion;
            string commandLine = aEngine.UIManager.UICommandLineArguments;
            //
            iSinkParams = new CISinkSerializationParameters( version, commandLine );
		}
		#endregion

		#region API
        public void Read( string aFileName )
        {
            Trace( "[CmdInput] Read() - aFileName: " + aFileName );
            try
            {
                // First create the tree
                SXILDocument doc = CreateDocumentTree( aFileName );

                // Then convert it to the list of elements that we care about
                ExtractData( doc );
            }
            catch ( CACmdLineException cmdLineException )
            {
                Trace( "[CmdInput] Read() - CACmdLineException: " + cmdLineException.Message + " " + cmdLineException.StackTrace );
                throw cmdLineException;
            }
            catch ( Exception generalException )
            {
                Trace( "[CmdInput] Read() - generalException: " + generalException.Message + " " + generalException.StackTrace );
                throw new CACmdLineException( "Error reading input xml file", generalException, CAPlugin.KErrCommandLinePluginArgumentsFileInvalid );
            }
            Trace( "[CmdInput] Read() - read OK: " + aFileName );
        }
        #endregion

		#region Properties
        public CISinkSerializationParameters SinkParameters
        {
            get { return iSinkParams; }
        }

        public CACmdLineFSEntityList<CACmdLineFileSource> SourceFiles
        {
            get { return iSources; }
        }

        public CACmdLineFSEntityList<CACmdLineFSEntity> MetaDataFiles
        {
            get { return iMetaData; }
        }
        #endregion

        #region Internal constants
        private const string KInputFileDocumentRootNode = "crash_analysis";
        private const string KInputFileCategorySource = "source";
        private const string KInputFileCategoryDebugMetaData = "debug_meta_data";
        private const string KInputFileCategoryParameters = "parameters";
        private const string KInputFileCategoryOutput = "output";
        private const string KInputFileCommandNameAnalysis = "analysis_type";
        private const string KInputFileCommandNameAnalysisFull = "FULL";
        private const string KInputFileCommandNameAnalysisSummary = "SUMMARY";
        #endregion

        #region Internal methods
        private SXILDocument CreateDocumentTree( string aFileName )
        {
            SXILDocument doc = new SXILDocument();

            // Read input file into document
            using ( SXILParser parser = new SXILParser( aFileName, KInputFileDocumentRootNode, doc ) )
            {
                parser.CategoryAdd( KInputFileCategorySource, new SXILParserNodeFileSystem() );
                parser.CategoryAdd( KInputFileCategoryDebugMetaData, new SXILParserNodeFileSystem() );
                parser.CategoryAdd( KInputFileCategoryParameters,
                    new SXILParserNodeCommand(),
                    new SXILParserNodeExtension()
                    );
                parser.CategoryAdd( KInputFileCategoryOutput, new SXILParserNodeFileSystem() );
                parser.Parse();
            }

            return doc;
        }

        private void ExtractData( SXILDocument aDocument )
        {
            foreach ( SXILElement element in aDocument )
            {
                if ( element is SXILElementCategory )
                {
                    SXILElementCategory category = (SXILElementCategory) element;
                    string name = category.Name.ToLower();
                    //
                    switch ( name )
                    {
                    case KInputFileCategorySource:
                        ExtractFileList<CACmdLineFileSource>( iSources, category );
                        break;
                    case KInputFileCategoryDebugMetaData:
                        // The debug meta data engine doesn't support directories anymore
                        // so we have to expand all directories to files.
                        ExtractFileList<CACmdLineFSEntity>( iMetaData, category );
                        break;
                    case KInputFileCategoryParameters:
                        ExtractParameters( category );
                        break;
                    case KInputFileCategoryOutput:
                        ExtractOutput( category );
                        break;
                    }
                }
            }

            // We don't require debug meta data if performing a summary operation. Otherwise, we do.
            if ( iMetaData.Count == 0 && iSinkParams.DetailLevel == CISinkSerializationParameters.TDetailLevel.EFull )
            {
                Trace( "[CmdInput] ExtractData() - WARNING - no debug meta data supplied for full analysis." );
            }
        
        }

        private void ExtractFileList<T>( CACmdLineFSEntityList<T> aList, SXILElementCategory aCategory ) where T : CACmdLineFSEntity, new()
        {
            foreach ( SXILElement element in aCategory )
            {
                if ( element is SXILElementFile )
                {
                    SXILElementFile file = (SXILElementFile) element;
                    Trace( "[CmdInput] ExtractFileList() - file: " + file );
                    if ( !file.Exists )
                    {
                        throw new FileNotFoundException( "File not found", file.Name );
                    }
                    //
                    aList.Add( file );
                }
                else if ( element is SXILElementDirectory )
                {
                    SXILElementDirectory dir = (SXILElementDirectory) element;
                    Trace( "[CmdInput] ExtractFileList() - dir:  " + dir );
                    if ( !dir.Exists )
                    {
                        throw new DirectoryNotFoundException( "Directory not found: " + dir.Name );
                    }
                    //
                    aList.AddRange( dir.Files );
                }
            }
        }

        private void ExtractParameters( SXILElementCategory aCategory )
        {
            foreach ( SXILElement element in aCategory )
            {
                if ( element is SXILElementExtension )
                {
                    SXILElementExtension entry = (SXILElementExtension) element;
                    //
                    string extension = entry.Name;
                    if ( !extension.StartsWith( "." ) )
                    {
                        extension = "." + extension;
                    }
                    //
                    if ( entry.Type == SXILElementExtension.TType.ETypeFailure )
                    {
                        Trace( "[CmdInput] ExtractFileList() - failed extension: " + extension );
                        iSinkParams.FileExtensionFailed = extension;
                    }
                    else if ( entry.Type == SXILElementExtension.TType.ETypeSuccess )
                    {
                        Trace( "[CmdInput] ExtractFileList() - success extension: " + extension );
                        iSinkParams.FileExtensionSuccess = extension;
                    }
                }
                else if ( element is SXILElementCommand )
                {
                    SXILElementCommand entry = (SXILElementCommand) element;
                    //
                    if ( entry.Name == KInputFileCommandNameAnalysis )
                    {
                        string type = entry.Details.Trim().ToUpper();
                        Trace( "[CmdInput] ExtractFileList() - command: " + type );
                        switch ( type )
                        {
                        case KInputFileCommandNameAnalysisFull:
                            iSinkParams.DetailLevel = CISinkSerializationParameters.TDetailLevel.EFull;
                            break;
                        case KInputFileCommandNameAnalysisSummary:
                            iSinkParams.DetailLevel = CISinkSerializationParameters.TDetailLevel.ESummary;
                            break;
                        default:
                            throw new NotSupportedException( "Unsupported analysis type" );
                        }
                    }
                    else
                    {
                        throw new NotSupportedException( "Unsupported command: " + entry.Name );
                    }
                }
            }
        }

        private void ExtractOutput( SXILElementCategory aCategory )
        {
            // We either output to file or directory - if both are present then bail out
            FileInfo savedFile = null;
            DirectoryInfo savedDir = null;
            //
            foreach ( SXILElement element in aCategory )
            {
                if ( element is SXILElementFile )
                {
                    if ( savedFile != null )
                    {
                        throw new InvalidDataException( "Output file already specified" );
                    }
                    else
                    {
                        SXILElementFile file = (SXILElementFile) element;
                        savedFile = file;
                    }
                }
                else if ( element is SXILElementDirectory )
                {
                    if ( savedDir != null )
                    {
                        throw new InvalidDataException( "Output directory already specified" );
                    }
                    else
                    {
                        SXILElementDirectory dir = (SXILElementDirectory) element;
                        savedDir = dir;
                    }
                }
            }
            
            // Ensure we have only one type
            if ( savedFile != null && savedDir != null )
            {
                throw new InvalidDataException( "Output must be EITHER file or directory" );
            }
            else if ( savedFile != null )
            {
                iSinkParams.OutputFile = savedFile;
            }
            else if ( savedDir != null )
            {
                iSinkParams.OutputDirectory = savedDir;
            }
        }

        public void Trace( string aMessage )
        {
            iEngine.UIManager.UITrace( aMessage );
        }

        public void Trace( string aFormat, params object[] aParams )
        {
            iEngine.UIManager.UITrace( aFormat, aParams );
        }
        #endregion

        #region Data members
        private readonly CAPluginCrashAnalysis iEngine;
        private readonly CISinkSerializationParameters iSinkParams;
        private CACmdLineFSEntityList<CACmdLineFSEntity> iMetaData = new CACmdLineFSEntityList<CACmdLineFSEntity>();
        private CACmdLineFSEntityList<CACmdLineFileSource> iSources = new CACmdLineFSEntityList<CACmdLineFileSource>();
        #endregion
	}
}