/*

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

using System.Collections.Generic;

using System.Text;

using SymbianUtils;

using SymbianDebugLib.Engine;

using CrashItemLib.Crash;

using CrashItemLib.Engine;

namespace CrashItemLib.PluginAPI

{

	public abstract class CFFReader

	{

        #region Enumerations

        public enum TState

        {

            EStateUninitialised = 0,

            EStateProcessing,

            EStateReady,

            EStateCorrupt

        }

        #endregion

        #region Delegates & events

		public enum TEvent

		{

			EReadingStarted = 0,

			EReadingProgress,

            EReadingContainerCreated,

			EReadingComplete,

		}

		public delegate void ReaderObserver( TEvent aEvent, CFFReader aReader, object aContext );

        public event ReaderObserver Observer;

        public delegate void ReaderExceptionHandler( Exception aException, CFFReader aReader );

        public event ReaderExceptionHandler ExceptionHandler;

		#endregion

		#region Constructors

		protected CFFReader( CFFPlugin aEngine, CFFSource aDescriptor )

		{

            iPlugin = aEngine;

            iDescriptor = aDescriptor;

		}

		#endregion

		#region API - abstract

        /// <summary>

        /// Called when Crash Analyser wants this plugin to read a

        /// native, i.e. format-specific crash file (i.e. not a trace file) 

        /// synchronously.

        /// </summary>

        public virtual void NativeReadInit()

        {

        }

        /// <summary>

        /// Called when Crash Analyser is going to start to send

        /// trace lines (that it will read on behalf of the plugin)

        /// that should be processed in order to identify embedded

        /// traces.

        /// 

        /// This method will only be called if the plugin claims to have

        /// some confidence in reading trace data.

        /// </summary>

        public virtual void TraceReadInit()

        {

        }

        /// <summary>

        /// Receive an individual trace line and process it if relevant

        /// </summary>

        /// <param name="aLine"></param>

        public virtual bool TraceReadOffer( CFFTraceLine aLine )

        {

            // Nothing to do

            return false;

        }

        /// <summary>

        /// Called when all trace lines have been delivered

        /// </summary>

        public virtual void TraceReadComplete()

        {

        }

		#endregion

        #region API - framework

        protected byte[] RawData

        {

            get { return Descriptor.RawData; }

        }

        protected void RawDataAdd()

        {

            // Save entire file

            RawDataClear();

            RawDataAdd( Descriptor.MasterFile );

        }

        protected void RawDataAdd( FileInfo aFile )

        {

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

            RawDataAdd( bytes );

        }

        protected void RawDataClear()

        {

            Descriptor.RawDataClear();

        }

        protected void RawDataAdd( byte[] aRawData )

        {

            Descriptor.RawDataAdd( aRawData );

        }

        #endregion

        #region Properties

        public TState State

        {

            get

            {

                lock ( this )

                {

                    return iState;

                }

            }

            set

            {

                lock ( this )

                {

                    iState = value;

                }

            }

        }

        public CFFPlugin Plugin

        {

            get { return iPlugin; }

        }

        public CFFSource Descriptor

        {

            get { return iDescriptor; }

        }

        public CIEngine CIEngine

		{

            get { return Plugin.DataProvider.Engine; }

		}

		#endregion

		#region Internal methods

		protected void NotifyEvent( TEvent aEvent )

		{

            NotifyEvent( aEvent, null );

		}

        protected void NotifyEvent( TEvent aEvent, object aContext )

        {

            // We must notify about "reading started" and "reading complete" only

            // once.

            //

            // When the plugin sends the "reading started" event, we must transition

            // to 'EStateProcessing.'

            //

            // When the plugin sends the "reading complete" event, we must transition

            // to 'EStateReady' except if there was an exception during processing,

            // in which case we remain as 'EStateCorrupt.'

            //

            // NB: NotifyException makes the transition to EStateCorrupt.

            //

            TState oldState = State;

            //

            bool notify = false;

            switch ( aEvent )

            {

            case TEvent.EReadingContainerCreated:

                notify = true;

                break;

            case TEvent.EReadingStarted:

                State = TState.EStateProcessing;

                notify = ( State != oldState );

                break;

            case TEvent.EReadingProgress:

                notify = true;

                break;

            case TEvent.EReadingComplete:

                if ( State == TState.EStateCorrupt )

                {

                    // There was an exception during processing. Do not

                    // change to 'ready' state in this situation.

                    // 

                    // However, we must still notify about the completion event!

                    notify = true;

                }

                else

                {

                    State = TState.EStateReady;

                    notify = ( State != oldState );

                }

                break;

            default:

                throw new NotSupportedException();

            }

            if ( notify )

            {

                if ( Observer != null )

                {

                    Observer( aEvent, this, aContext );

                }

            }

        }

        protected void NotifyException( Exception aException )

        {

            State = TState.EStateCorrupt;

            //

            if ( ExceptionHandler != null )

            {

                ExceptionHandler( aException, this );

            }

        }

		#endregion

        #region Internal methods - called by CIEngineSource to carry out operations

        internal void OnNativeReadInit()

        {

            // Indicate reading started

            NotifyEvent( TEvent.EReadingStarted );

            try

            {

                NativeReadInit();

            }

            catch ( Exception e )

            {

                NotifyException( e );

                NotifyEvent( TEvent.EReadingComplete );

            }

        }

        internal void OnTraceReadInit()

        {

            // Indicate reading started

            NotifyEvent( TEvent.EReadingStarted );

            try

            {

                TraceReadInit();

            }

            catch ( Exception e )

            {

                NotifyException( e );

                NotifyEvent( TEvent.EReadingComplete );

            }

        }

        internal void OnTraceReadOffer( CFFTraceLine aLine )

        {

            try

            {

                bool consumed = TraceReadOffer( aLine );

                if ( consumed )

                {

                    RawDataAdd( aLine.ToBinary() );

                }

            }

            catch ( Exception e )

            {

                NotifyException( e );

            }

        }

        internal void OnTraceReadComplete()

        {

            try

            {

                TraceReadComplete();

            }

            catch ( Exception e )

            {

                NotifyException( e );

                NotifyEvent( TEvent.EReadingComplete );

            }

        }

        #endregion

		#region Data members

        private TState iState = TState.EStateUninitialised;

        private readonly CFFPlugin iPlugin;

        private readonly CFFSource iDescriptor;

		#endregion

	}

}