/*

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

using System.Collections.Generic;

using SymbianUtils;

using SymbianDebugLib.Engine;

using CrashItemLib.Engine;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Messages;

using CrashItemLib.Crash.Container;

using CrashItemLib.Crash.Base.DataBinding;

namespace CrashItemLib.Crash.Base

{

	public abstract class CIElement : IEnumerable<CIElement>

    {

        #region Delegates & events

        public delegate void CIElementEventHandler( CIElement aElement );

        public delegate void CIMultiElementEventHandler( CIElement aSelf, CIElement aOther );

        public event CIMultiElementEventHandler ChildAdded = null;

        #endregion

        #region Enumerations

        internal enum TAutoPopulateType

        {

            EAutoPopulateDisabled = 0,

            EAutoPopulateEnabled

        }

        public enum TChildSearchType

        {

            EDirectChildrenOnly = 0,

            EEntireHierarchy

        }

        #endregion

        #region Constructors

        internal CIElement( int aId )

            : this( aId, false )

        {

            // NB: to be called only by the container itself since everything else

            // must specify a valid container object

            System.Diagnostics.Debug.Assert( this is CIContainer );

        }

        internal CIElement( CIContainer aContainer )

            : this( aContainer, TAutoPopulateType.EAutoPopulateDisabled )

		{

		}

        internal CIElement( CIContainer aContainer, CIElement aParent )

            : this( aContainer )

        {

            iParent = aParent;

        }

        internal CIElement( CIContainer aContainer, TAutoPopulateType aDataBindingAutoPopulate )

            : this( aContainer.GetNextElementId(), aDataBindingAutoPopulate == TAutoPopulateType.EAutoPopulateEnabled )

        {

            iContainer = aContainer;

        }

        internal CIElement( CIContainer aContainer, CIElement aParent, TAutoPopulateType aDataBindingAutoPopulate )

            : this( aContainer, aDataBindingAutoPopulate )

        {

            iParent = aParent;

        }

        private CIElement( long aId, bool aDataBindingAutoPopulate )

        {

            iId = new CIElementId( aId );

            iDataBindingModel = new CIDBModel( this, aDataBindingAutoPopulate );

        }

        #endregion

        #region API - Framework Properties

        public virtual string Name

        {

            get { return string.Empty; }

            set { }

        }

        public virtual CIElementId Id

        {

            get { return iId; }

            set 

            { 

                iId = value;

                IsIdExplicit = true;

            }

        }

        #endregion

        #region API - Children

        public virtual int Count

        {

            get 

            {

                int ret = 0;

                //

                lock ( iSyncLock )

                {

                    if ( iChildren != null )

                    {

                        ret = iChildren.Count;

                    }

                }

                //

                return ret;

            }

        }

        public bool HasChildren

        {

            get

            {

                bool ret = false;

                //

                lock ( iSyncLock )

                {

                    if ( iChildren != null )

                    {

                        ret = ( iChildren.Count > 0 );

                    }

                }

                //

                return ret;

            }

        }

        public virtual void AddChild( CIElement aChild )

        {

            if ( aChild != null )

            {

                // If we have been restricted to a specific 

                // type of child element, then check aChild against

                // it...

                Type t = aChild.GetType();

                ValidateChildType( t );

                lock ( iSyncLock )

                {

                    if ( iChildren == null )

                    {

                        iChildren = new CIElementList<CIElement>( Container );

                        iChildren.IsInContainer = this.IsInContainer;

                    }

                    if ( aChild.Parent == null )

                    {

                        aChild.Parent = this;

                    }

                    iChildren.Add( aChild );

                }

                OnElementAddedToSelf( aChild );

            }

        }

        public virtual void AddChildren( CIElement[] aChildren )

        {

            for ( int i = aChildren.Length - 1; i >= 0; i-- )

            {

                AddChild( aChildren[ i ] );

            }

        }

        public virtual void RemoveChild( CIElement aChild )

        {

            if ( aChild == null )

            {

                throw new ArgumentException( "Child is null" );

            }

            if ( HasChildren && iChildren.Count > 0 )

            {

                lock ( iSyncLock )

                {

                    iChildren.Remove( aChild );

                }

            }

        }

        public virtual void RemoveChildren( Type aType )

        {

            if ( HasChildren && iChildren.Count > 0 )

            {

                lock ( iSyncLock )

                {

                    int count = iChildren.Count;

                    for ( int i = count - 1; i >= 0; i-- )

                    {

                        CIElement child = iChildren[ i ];

                        if ( aType.IsAssignableFrom( aType ) )

                        {

                            iChildren.Remove( child );

                        }

                    }

                }

            }

        }

        public virtual void Clear()

        {

            lock ( iSyncLock )

            {

                if ( iChildren != null )

                {

                    iChildren.Clear();

                }

            }

        }

        public virtual bool Contains( CIElement aElement )

        {

            return Contains( aElement.Id );

        }

        public virtual bool Contains( CIElementId aId )

        {

            bool ret = false;

            //

            lock ( iSyncLock )

            {

                if ( iChildren != null )

                {

                    ret = iChildren.Contains( aId );

                }

            }

            //

            return ret;

        }

        public CIElement this[ CIElementId aId ]

        {

            get

            {

                CIElement ret = null;

                //

                lock ( iSyncLock )

                {

                    if ( Contains( aId ) )

                    {

                        System.Diagnostics.Debug.Assert( iChildren != null );

                        ret = iChildren[ aId ];

                    }

                }

                //

                return ret;

            }

        }

        public CIElement this[ int aIndex ]

        {

            get

            {

                CIElement ret = null;

                //

                lock ( iSyncLock )

                {

                    if ( iChildren != null )

                    {

                        ret = iChildren[ aIndex ];

                    }

                }

                //

                return ret;

            }

        }

        public CIElement ChildByType( Type aType )

        {

            CIElement ret = null;

            //

            lock ( iSyncLock )

            {

                foreach ( CIElement element in this )

                {

                    if ( aType.IsAssignableFrom( element.GetType() ) )

                    {

                        ret = element;

                        break;

                    }

                }

            }

            //

            return ret;

        }

        public CIElementList<T> ChildrenByType<T>() where T: CIElement

        {

            CIElementList<T> ret = ChildrenByType<T>( TChildSearchType.EDirectChildrenOnly );

            return ret;

        }

        public CIElementList<T> ChildrenByType<T>( Predicate<T> aPredicate ) where T : CIElement

        {

            CIElementList<T> ret = ChildrenByType<T>( TChildSearchType.EDirectChildrenOnly, aPredicate );

            return ret;

        }

        public CIElementList<T> ChildrenByType<T>( TChildSearchType aType ) where T : CIElement

        {

            return ChildrenByType<T>( aType, null );

        }

        public CIElementList<T> ChildrenByType<T>( TChildSearchType aType, Predicate<T> aPredicate ) where T : CIElement

        {

            CIElementList<T> ret = new CIElementList<T>( Container );

            GetChildrenByType<T>( ret, aType, aPredicate );

            return ret;

        }

        internal CIElementList<CIElement> Children

        {

            get

            {

                CIElementList<CIElement> ret = null;

                //

                lock ( iSyncLock )

                {

                    ret = iChildren;

                    //

                    if ( ret == null )

                    {

                        ret = new CIElementList<CIElement>( Container );

                    }

                }

                //

                return ret;

            }

        }

        #endregion

        #region API - Data Binding framework

        public virtual void PrepareColumns()

        {

            DataBindingModel.ClearColumns();

            DataBindingModel.TryAutoPopulateColumns( this );

        }

        public virtual void PrepareRows()

        {

            DataBindingModel.ClearRows();

            DataBindingModel.TryAutoPopulateCells( this );

        }

        #endregion

        #region API - Parentage

        public bool HasParent

        {

            get

            {

                lock ( iSyncLock )

                {

                    return iParent != null;

                }

            }

        }

        public virtual CIElement Parent

        {

            get

            {

                lock ( iSyncLock )

                {

                    return iParent;

                }

            }

            internal set 

            {

                lock ( iSyncLock )

                {

                    iParent = value;

                }

            }

        }

        #endregion

        #region Properties

        public virtual bool IsInContainer

        {

            get

            {

                lock ( iSyncLock )

                {

                    return ( iFlags & TFlags.EFlagsIsInContainer ) == TFlags.EFlagsIsInContainer;

                }

            }

            internal set

            {

                // Don't allow it to change if we're locked down.

                if ( IsFinalized == false )

                {

                    bool oldValue = IsInContainer;

                    if ( oldValue != value )

                    {

                        // Set new flag value

                        lock ( iSyncLock )

                        {

                            if ( value )

                            {

                                iFlags |= TFlags.EFlagsIsInContainer;

                            }

                            else

                            {

                                iFlags &= ~TFlags.EFlagsIsInContainer;

                            }

                        }

                        // Fire internal call that reflects new state. This notifies the

                        // container about our registration status and in turn, the container

                        // can notify it's observers about our presence/remove within container.

                        OnIsInContainerChanged();

                        // Ensure children are also in/out of container

                        lock ( iSyncLock )

                        {

                            if ( iChildren != null )

                            {

                                iChildren.IsInContainer = value;

                            }

                        }

                    }

                }

            }

        }

        public bool IsIdExplicit

        {

            get

            {

                lock ( iSyncLock )

                {

                    return ( iFlags & TFlags.EFlagsIdWasExplicitlySet ) == TFlags.EFlagsIdWasExplicitlySet;

                }

            }

            private set 

            {

                lock ( iSyncLock )

                {

                    if ( value )

                    {

                        iFlags |= TFlags.EFlagsIdWasExplicitlySet;

                    }

                    else

                    {

                        iFlags &= ~TFlags.EFlagsIdWasExplicitlySet;

                    }

                }

            }

        }

        public virtual CIEngine Engine

        {

            get { return Container.Engine; }

        }

        public CIContainer Container

        {

            get

            {

                lock ( iSyncLock )

                {

                    return iContainer;

                }

            }

            internal set 

            {

                lock ( iSyncLock )

                {

                    iContainer = value;

                }

            }

        }

        public CIDBModel DataBindingModel

        {

            get { return iDataBindingModel; }

        }

        protected bool IsToBeFinalizedLast

        {

            get

            {

                lock ( iSyncLock )

                {

                    return ( iFlags & TFlags.EFlagsIsToBeFinalizedLast ) == TFlags.EFlagsIsToBeFinalizedLast;

                }

            }

            set

            {

                lock ( iSyncLock )

                {

                    if ( value )

                    {

                        iFlags |= TFlags.EFlagsIsToBeFinalizedLast;

                    }

                    else

                    {

                        iFlags &= ~TFlags.EFlagsIsToBeFinalizedLast;

                    }

                }

            }

        }

        internal bool IsFinalized

        {

            get

            {

                lock ( iSyncLock )