/*
* 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.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using SymbianUtils.DataBuffer.Entry;

namespace SymbianUtils.DataBuffer.Primer
{
    public class DataBufferPrimer
    {
        #region Delegates & Events
        public delegate void DataBufferPrimerUnhandledLine( DataBufferPrimer aPrimer, DataBuffer aBuffer, string aLine );
        public event DataBufferPrimerUnhandledLine LineNotHandled;

        public delegate void DataBufferPrimerCompleteHandler( DataBufferPrimer aPrimer, DataBuffer aBuffer, uint aFirstByteAddress, uint aLastByteAddress );
        public event DataBufferPrimerCompleteHandler PrimerComplete;
        #endregion

        #region Constructors
        public DataBufferPrimer( DataBuffer aBuffer )
        {
            iDataBuffer = aBuffer;
        }
        #endregion

        #region API
        public void Prime( IEnumerable<string> aLines )
        {
            iDataBuffer.Clear();
            //
            foreach ( string line in aLines )
            {
                PrimeLine( line );
            }

            Primed = true;
        }

        public void PrimeLine( string aLine )
        {
            Match m = iRawDataRegEx.Match( aLine );
            //
            if ( m.Success )
            {
                uint startOfLineAddress = ExtractDataSourceEntryFromMatch( m );
                
                // If the data buffer has never had an address applied to it, then set it now
                if ( iHaveSetFirstAddress == false )
                {
                    iDataBuffer.AddressOffset = startOfLineAddress;
                    iHaveSetFirstAddress = true;
                }
            }
            else if ( LineNotHandled != null )
            {
                LineNotHandled( this, iDataBuffer, aLine );
            }
        }

        public void Prime( string aBinaryFileName )
        {
            Prime( aBinaryFileName, 0 );
        }

        public void Prime( string aBinaryFileName, uint aAddressOfFirstByte )
        {
            FileInfo info = new FileInfo( aBinaryFileName );
            if ( info.Exists )
            {
                int length = (int) info.Length;
                //
                byte[] bytes = new byte[ length ];
                using ( FileStream stream = new FileStream( aBinaryFileName, FileMode.Open, FileAccess.Read, FileShare.Read ) )
                {
                    stream.Read( bytes, 0, length );
                }
                //
                Prime( bytes, aAddressOfFirstByte );
            }
        }

        public void Prime( IEnumerable<byte> aBytes, uint aAddressOfFirstByte )
        {
            iDataBuffer.Clear();

            // Set the starting address
            iDataBuffer.AddressOffset = aAddressOfFirstByte;

            // Read bytes
            uint offset = 0;
            foreach ( byte b in aBytes )
            {
                DataBufferByte entry = new DataBufferByte( b, offset++ );
                iDataBuffer.Add( entry );
            }

            Primed = true;
        }

        public void Prime( DataBuffer aBuffer )
        {
            iDataBuffer.Clear();
            iDataBuffer.Set( aBuffer );
            Primed = true;
        }
        #endregion

        #region Properties
        public bool Primed
        {
            get { return iPrimed; }
            private set
            {
                iPrimed = value;
                if ( Primed )
                {
                    uint firstByte = ( iDataBuffer.Count > 0 ) ? iDataBuffer.First.Address : 0;
                    uint lastByte = ( iDataBuffer.Count > 0 ) ? iDataBuffer.Last.Address : 0;
                    //
                    if ( PrimerComplete != null )
                    {
                        PrimerComplete( this, iDataBuffer, firstByte, lastByte );
                    }
                }
            }
        }
        #endregion

        #region Internal methods
        private uint ExtractDataSourceEntryFromMatch( Match aMatch )
        {
            System.Diagnostics.Debug.Assert( aMatch.Success );

            uint address = 0;
            uint nextExpectedAddress = 0;
            if ( iDataBuffer.Count > 0 )
            {
                nextExpectedAddress = iDataBuffer.Last.Address + 1;
            }
            //
            GroupCollection groups = aMatch.Groups;
            CaptureCollection data = groups[ "Data" ].Captures;

            if ( data.Count > 0 )
            {
                address = System.Convert.ToUInt32( groups[ "Address" ].Value, 16 );

                // Validate the address
                if ( nextExpectedAddress != 0 && address != nextExpectedAddress )
                {
                    throw new Exception( string.Format( "Data is corrupt - expected: 0x{0:x8}, actual: 0x{1:x8}", nextExpectedAddress, address ) );
                }
                else
                {
                    foreach ( Capture capture in data )
                    {
                        string val = capture.Value.Trim();
                        byte b = System.Convert.ToByte( val, 16 );
                        DataBufferByte entry = new DataBufferByte( b, (uint) iDataBuffer.Count );
                        iDataBuffer.Add( entry );
                    }
                }
            }

            return address;
        }
        #endregion

        #region Data members
        private static readonly Regex iRawDataRegEx = new Regex( "(?:.*)\r\n(?<Address>[a-fA-F0-9]{8})\r\n\\:\\s{1}\r\n(?<Data>(?:[a-fA-F0-9]{2})\\s{1}){1,16}\r\n(?:.*)", RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled );
        private readonly DataBuffer iDataBuffer;
        private bool iPrimed = false;
        private bool iHaveSetFirstAddress = false;
        #endregion
    }
}