/*

* 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.Text.RegularExpressions;

namespace SymbianUtils.Range

{

	public class AddressRange : IComparable<AddressRange>

    {

        #region Delegates & events

        public delegate void ChangeHandler( AddressRange aAddressRange );

        public event ChangeHandler RangeChanged; 

        #endregion

        #region Constructors

        public AddressRange()

		{

		}

        public AddressRange( string aSpecifier )

        {

            this.Parse( aSpecifier );

        }

        public AddressRange( uint aMin, uint aMax )

        {

            iMin = aMin;

            iMax = aMax;

        }

        public AddressRange( long aMin, long aMax )

            : this( (uint) aMin, (uint) aMax )

        {

        }

        public AddressRange( AddressRange aCopy )

            : this( aCopy.Min, aCopy.Max )

        {

        }

        #endregion

        #region API

        public void Set( uint aMin, uint aMax )

        {

            iMax = aMax;

            iMin = aMin;

        }

        public bool Contains( uint aAddress )

        {

            bool ret = ( aAddress >= iMin && aAddress <= iMax );

            return ret;

        }

        public bool Contains( long aAddress )

        {

            bool ret = Contains( (uint) aAddress );

            return ret;

        }

        public bool Contains( AddressRange aRange )

        {

            bool ret = Contains( aRange.Min ) && Contains( aRange.Max );

            return ret;

        }

        public void Reset()

        {

            iMin = uint.MaxValue;

            iMax = uint.MinValue;

            //

            OnChanging();

        }

        public void Update( AddressRange aRange )

        {

            AddressRange transaction = TransactionBegin();

            //

            UpdateMin( aRange.Min );

            UpdateMax( aRange.Max );

            //

            TransactionEnd( transaction );

        }

        public void UpdateMin( uint aProposedMin )

        {

            uint old = iMin;

            iMin = Math.Min( iMin, aProposedMin );

            //

            if ( old != iMin )

            {

                OnChanging();

            }

        }

        public void UpdateMax( uint aProposedMax )

        {

            uint old = iMax;

            iMax = Math.Max( iMax, aProposedMax );

            //

            if ( old != iMax )

            {

                OnChanging();

            }

        }

        public void UpdateMin( long aProposedMin )

        {

            UpdateMin( (uint) aProposedMin );

        }

        public void UpdateMax( long aProposedMax )

        {

            UpdateMax( (uint) aProposedMax );

        }

        public void Parse( string aValue )

        {

            Match m = KRegEx.Match( aValue );

            if ( m.Success )

            {

                string min = m.Groups[ "Min" ].Value.Replace( "0x", string.Empty );

                string max = m.Groups[ "Max" ].Value.Replace( "0x", string.Empty );

                // Also need to know if they are hex or decimal specifiers

                int baseMin = ( m.Groups[ 0 ].Value == "0x" ? 16 : 10 );

                int baseMax = ( m.Groups[ 1 ].Value == "0x" ? 16 : 10 );

                // Now convert

                uint valueMin = System.Convert.ToUInt32( min, baseMin );

                uint valueMax = System.Convert.ToUInt32( max, baseMax );

                // Make range...

                AddressRange transaction = TransactionBegin();

                //

                UpdateMin( valueMin );

                UpdateMin( valueMax );

                //

                TransactionEnd( transaction );

            }

            else

            {

                throw new ArgumentException( "Invalid range format - expected [0x]AAA - [0x]BBB" );

            }

        }

        #endregion

        #region Properties

        public uint Min

        {

            get { return iMin; }

            set 

            {

                if ( iMin != value )

                {

                    iMin = value;

                    OnChanging();

                }

            }

        }

        public uint Max

        {

            get { return iMax; }

            set

            {

                if ( iMax != value )

                {

                    iMax = value;

                    OnChanging();

                }

            }

        }

        public uint Size

        {

            get 

            { 

                uint ret = Max - Min + 1;

                return ret;

            }

        }

        public bool IsValid

        {

            get

            {

                bool goodMin = ( iMin != uint.MaxValue );

                bool goodMax = ( iMax != uint.MinValue );

                //

                return ( goodMin && goodMax );

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            ret.AppendFormat( "{0:x8}-{1:x8}", Min, Max );

            return ret.ToString();

        }

        public override int GetHashCode()

        {

            return (int) ( Min ^ Max );

        }

        public override bool Equals( object aObject )

        {

            bool ret = false;

            //

            if ( aObject != null )

            {

                if ( aObject is AddressRange )

                {

                    AddressRange other = (AddressRange) aObject;

                    //

                    int compareMin = other.Min.CompareTo( this.Min );

                    int compareMax = other.Max.CompareTo( this.Max );

                    //

                    ret = ( compareMin == 0 && compareMax == 0 );

                }

                else

                {

                    ret = base.Equals( aObject );

                }

            }

            //

            return ret;

        }

        #endregion

        #region Operators

        public static implicit operator AddressRange( string aSpecifier )

        {

            AddressRange ret = new AddressRange( aSpecifier );

            return ret;

        }

        #endregion

        #region Internal regular expressions

        private static readonly Regex KRegEx = new Regex(

              "(?<Min>(?((0x))0x[A-Fa-f0-9]{1,8}|[0-9]{1,8}))\\s*\\-\\s*(?<"+

              "Max>(?((0x))0x[A-Fa-f0-9]{1,8}|[0-9]{1,8}))",

            RegexOptions.CultureInvariant

            | RegexOptions.Compiled

            );

        #endregion

        #region From IComparable<AddressRange5>

        public int CompareTo( AddressRange aOther )

        {

            int ret = 1;

            //

            if ( aOther != null )

            {

                ret = this.Min.CompareTo( aOther.Min );

            }

            //

            return ret;

        }

        #endregion

        #region Internal methods

        private void OnChanging()

        {

            if ( !InTransaction )

            {

                OnChanged();

            }

        }

        protected virtual void OnChanged()

        {

            if ( RangeChanged != null )

            {

                RangeChanged( this );

            }

        }

        private bool InTransaction

        {

            get { return iTransactionCount > 0; }

        }

        private AddressRange TransactionBegin()

        {

            ++iTransactionCount;

            //

            AddressRange ret = new AddressRange( this.Min, this.Min );

            return ret;

        }

        private void TransactionEnd( AddressRange aTransaction )

        {

            System.Diagnostics.Debug.Assert( iTransactionCount > 0 );

            --iTransactionCount;

            //

            if ( aTransaction.CompareTo( this ) != 0 )

            {

                OnChanging();

            }

        }

        #endregion

        #region Data members

        private uint iMin = uint.MaxValue;

        private uint iMax = uint.MinValue;

        private int iTransactionCount = 0;

        #endregion

    }

}