/*
* 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 System.Text.RegularExpressions;
using DecompressETB.Types;
using SymbianUtils.Range;

namespace DecompressETB.Utilities
{
    public class RVCTDiassemblyUtility
    {
        #region Constructor
        public RVCTDiassemblyUtility()
        {
        }
        #endregion

        #region API
        public string Disassemble( uint aAddress )
        {
            string ret = "Unknown instruction";
            //
            RVCTFunctionComparer comparer = new RVCTFunctionComparer();
            RVCTDisassemblyFunction temp = new RVCTDisassemblyFunction( aAddress );
            int pos = iFunctions.BinarySearch( temp, comparer );
            if ( pos >= 0 && pos < iFunctions.Count )
            {
                temp = iFunctions[ pos ];
                System.Diagnostics.Debug.Assert( temp.AddressRange.Contains( aAddress ) );
                //
                ret = temp[ aAddress ];
            }
            //
            return ret;
        }

        public void Read( string aFileName, uint aGlobalBaseAddress )
        {
            using ( StreamReader reader = new StreamReader( aFileName ) )
            {
                RVCTDisassemblyFunction fn = LastFunction;
                //
                string line = reader.ReadLine();
                while ( line != null )
                {
                    Match m = null;
                    //
                    m = KRegExFunction.Match( line );
                    if ( m.Success )
                    {
                        if ( fn != null )
                        {
                            fn.Finalise();

                            // Only save functions that contain disassembly
                            if ( fn.Count > 0 )
                            {
                                iFunctions.Add( fn );
                            }
                        }

                        fn = new RVCTDisassemblyFunction( m.Groups[ "Name" ].Value, aGlobalBaseAddress );
                    }
                    else if ( fn != null )
                    {
                        fn.Offer( line );
                    }
                    //
                    line = reader.ReadLine();
                }
                
                // Finalise any pending function
                if ( fn != null )
                {
                    fn.Finalise();
                }
            }
        }
        #endregion

        #region Properties
        private RVCTDisassemblyFunction LastFunction
        {
            get
            {
                RVCTDisassemblyFunction ret = null;
                int count = iFunctions.Count;
                if ( count > 0 )
                {
                    ret = iFunctions[ count - 1 ];
                }
                return ret;
            }
        }
        #endregion

        #region Internal classes
        class RVCTFunctionComparer : IComparer<RVCTDisassemblyFunction>
        {
            public int Compare( RVCTDisassemblyFunction aLeft, RVCTDisassemblyFunction aRight )
            {
                int ret = -1;
                //
                AddressRange lr = aLeft.AddressRange;
                AddressRange rr = aRight.AddressRange;
                //
                if ( lr.Contains( rr ) || rr.Contains( lr ) )
                {
                    ret = 0;
                }
                else
                {
                    ret = lr.CompareTo( rr );
                }
                //
                return ret;
            }
        }
        #endregion

        #region Internal constants
        private static readonly Regex KRegExFunction = new Regex(
              @"^\s{4}(?<Name>[A-Za-z_0-9]+)$",
            RegexOptions.Multiline
            | RegexOptions.CultureInvariant
            | RegexOptions.IgnorePatternWhitespace
            | RegexOptions.Compiled
            );
        #endregion

        #region Data members
        private List<RVCTDisassemblyFunction> iFunctions = new List<RVCTDisassemblyFunction>();
        #endregion
    }

    internal class RVCTDisassemblyFunction
    {
        #region Constructor
        public RVCTDisassemblyFunction( string aName, uint aBaseAddress )
        {
            iName = aName;
            iBaseAddress = aBaseAddress;
        }

        public RVCTDisassemblyFunction( uint aAddress )
        {
            iName = string.Empty;
            iBaseAddress = aAddress;
            iAddressRange = new AddressRange( aAddress, aAddress );
        }
        #endregion

        #region API
        internal void Finalise()
        {
            int size = InstructionSize;
            iAddressRange = new AddressRange( iFirstInstructionAddress, iFirstInstructionAddress + ( iInstructions.Count * size ) - 1 );
        }

        internal void Offer( string aLine )
        {
            Match m = KRegExInstruction.Match( aLine );
            if ( m.Success )
            {
                // get offset address
                Group addressGroup = m.Groups[ "Address" ];
                uint address = uint.Parse( addressGroup.Value, System.Globalization.NumberStyles.HexNumber ) - KCodeBase;

                // Convert to global address
                address += iBaseAddress;
                if ( iFirstInstructionAddress == 0 )
                {
                    iFirstInstructionAddress = address;
                }

                // Create record
                string text = aLine.Substring( addressGroup.Index + addressGroup.Length + 1 ).Trim();
                iInstructions.Add( address, text );
            }
        }
        #endregion

        #region Properties
        public int Count
        {
            get { return iInstructions.Count; }
        }

        public int InstructionSize
        {
            get
            {
                int ret = 4;
                //
                if ( iInstructions.Count >= 2 )
                {
                    List<uint> addresses = new List<uint>();
                    //
                    foreach ( KeyValuePair<uint, string> i in iInstructions )
                    {
                        addresses.Add( i.Key );
                        if ( addresses.Count == 2 )
                        {
                            break;
                        }
                    }
                    //
                    if ( addresses.Count == 2 )
                    {
                        int diff = (int) ( addresses[ 1 ] - addresses[ 0 ] );
                        ret = diff;
                    }
                }
                //
                return ret;
            }
        }

        public AddressRange AddressRange
        {
            get
            {
                return iAddressRange;
            }
        }

        internal string this[ uint aAddress ]
        {
            get
            {
                string ret = "??? No exact match";
                //
                if ( iInstructions.ContainsKey( aAddress ) )
                {
                    ret = iInstructions[ aAddress ];
                }
                //
                return ret;
            }
        }
        #endregion

        #region Internal constants
        private const uint KCodeBase = 0x8000;
        private static readonly Regex KRegExInstruction = new Regex(
              "^\\s{8}\r\n0x(?<Address>.{8}):\r\n\\s{4}\r\n(?<Instruction>.{8})\r\n" +
              "\\s{4}\r\n(?<Ascii>.{4})\r\n\\s{4}\r\n(?<Memnonic>\\p{Lu}*)\r\n\\s+\r\n" +
              "(?<Params>.+)\r\n$",
            RegexOptions.Multiline
            | RegexOptions.CultureInvariant
            | RegexOptions.IgnorePatternWhitespace
            | RegexOptions.Compiled
            );
        #endregion

        #region Data members
        private readonly string iName;
        private readonly uint iBaseAddress;
        private uint iFirstInstructionAddress;
        private AddressRange iAddressRange;
        private Dictionary<uint, string> iInstructions = new Dictionary<uint, string>();
        #endregion
    }
}