/*
* 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.IO;
using SymbianUtils;
using SymbianUtils.Settings;
using SymbianUtils.FileSystem;
using SymbianDebugLib.Engine;
using SymbianDebugLib.PluginAPI;
using SymbianDebugLib.Entity.Descriptors;

namespace SymbianDebugLib.Entity.Manager
{
    public class DbgEntityManager : IEnumerable<DbgEntity>, IXmlSettingsExtended
    {
        #region Constructors
        internal DbgEntityManager( DbgEngine aEngine )
        {
            iEngine = aEngine;
        }
        #endregion

        #region API
        public void Clear()
        {
            foreach ( KeyValuePair<string, DbgEntityListCategorised> kvp in iLists )
            {
                DbgEntityListCategorised list = kvp.Value;

                // Tell the descriptor it is being cleared
                list.Descriptor.OnCleared();

                // Get rid of the list
                list.Dispose();
            }
            //
            iLists.Clear();
            iDisplayOrderList.Clear();
            Engine.OnCleared();
        }

        public DbgEntity Add( FSEntity aFSEntity )
        {
            DbgEntityDescriptorManager descManager = Engine.DescriptorManager;
            //
            DbgEntity entity = descManager.Create( aFSEntity );
            if ( entity != null )
            {
                SaveEntity( entity );
            }
            //
            return entity;
        }

        public DbgEntity AddFile( FileInfo aFile )
        {
            return Add( new FSEntityFile( aFile ) );
        }

        public DbgEntity AddDirectory( DirectoryInfo aDirectory )
        {
            return Add( new FSEntityDirectory( aDirectory ) );
        }

        public void Remove( DbgEntity aEntity )
        {
            DbgEntityDescriptor descriptor = aEntity.Descriptor;
            if ( descriptor != null )
            {
                DbgEntityListCategorised list;
                if ( iLists.TryGetValue( descriptor.CategoryName, out list ) )
                {
                    // Try to find the entity from the list and, if found,
                    // destroy it.
                    using ( DbgEntity removed = list.Remove( aEntity ) )
                    {
                        if ( removed != null )
                        {
                            // Tell the entity
                            removed.OnRemoved();

                            // Tell everybody else
                            Engine.OnRemoved( removed );
                        }
                    }
                }
                if ( iDisplayOrderList.TryGetValue( descriptor, out list ) )
                {
                    iDisplayOrderList.Remove( descriptor );
                }
            }
        }

        public bool IsReadyToPrime( out string aErrorList )
        {
            bool ready = true;
            aErrorList = string.Empty;
            //
            foreach ( DbgEntity e in this )
            {
                if ( !e.IsReadyToPrime( out aErrorList ) )
                {
                    ready = false;
                    break;
                }
            }
            //
            return ready;
        }

        public bool Contains( FSEntity aFSEntity )
        {
            bool ret = false;
            //
            foreach ( KeyValuePair<DbgEntityDescriptor, DbgEntityListCategorised> kvp in iDisplayOrderList )
            {
                DbgEntityListCategorised list = kvp.Value;
                if ( list.Contains( aFSEntity ) )
                {
                    ret = true;
                    break;
                }
            }
            //
            return ret;
        }
        #endregion

        #region Properties
        public int Count
        {
            get
            {
                int ret = 0;
                //
                foreach ( KeyValuePair<DbgEntityDescriptor, DbgEntityListCategorised> kvp in iDisplayOrderList )
                {
                    ret += kvp.Value.Count;
                }
                //
                return ret;
            }
        }

        public DbgEntity this[ int aIndex ]
        {
            get
            {
                int i = 0;
                DbgEntity ret = null;
                //
                foreach ( KeyValuePair<DbgEntityDescriptor, DbgEntityListCategorised> kvp in iDisplayOrderList )
                {
                    DbgEntityListCategorised list = kvp.Value;
                    int listCount = list.Count;
                    if ( aIndex < ( i + listCount ) )
                    {
                        ret = list[ aIndex - i ];
                        break;
                    }
                    else
                    {
                        i += listCount;
                    }
                }
                //
                if ( ret == null )
                {
                    throw new ArgumentException( "aIndex is out of range" );
                }
                //
                return ret;
           }
        }

        public DbgEngine Engine
        {
            get { return iEngine; }
        }

        public FSEntity[] FileSystemEntities
        {
            get
            {
                List<FSEntity> entities = new List<FSEntity>();
                //
                foreach ( DbgEntity e in this )
                {
                    FSEntity clone = FSEntity.New( e );
                    entities.Add( clone );
                }
                //
                return entities.ToArray();
            }
        }
        #endregion

        #region Event handlers
        #endregion

        #region Settings related
        public void XmlSettingsSave( XmlSettings aSettings, string aCategory )
        {
            aSettings.Clear();
            aSettings[ aCategory, "__Count" ] = Count;
            int index = 0;
            foreach ( DbgEntity entity in this )
            {
                string entityCategory = string.Format( "DbgEntity_{0:d5}", index++ );

                // Get the category where we'll save the settings for this entity to...
                XmlSettingCategory category = aSettings[ entityCategory ];

                // Save entity specific settings
                entity.Save( category );
            }
        }

        public void XmlSettingsLoad( XmlSettings aSettings, string aCategory )
        {
            Clear();
            //
            int count = aSettings.Load( aCategory, "__Count", 0 );
            for ( int i = 0; i < count; i++ )
            {
                try
                {
                    // Create category name and try to obtain it...
                    string entityCategory = string.Format( "DbgEntity_{0:d5}", i );
                    XmlSettingCategory category = aSettings[ entityCategory ];
                    if ( category != null )
                    {
                        // Make a new entity object based upon the type
                        DbgEntityDescriptorManager descManager = Engine.DescriptorManager;
                        DbgEntity entity = descManager.Create( category );
                        if ( entity != null )
                        {
                            SaveEntity( entity );
                        }
                    }
                }
                catch ( Exception )
                {
                }
            }
        }
        #endregion

        #region Internal properties
        #endregion

        #region Internal methods
        private void SaveEntity( DbgEntity aEntity )
        {
            // Check if the dictionary already contains an entity descriptor list
            DbgEntityDescriptor descriptor = aEntity.Descriptor;
            DbgEntityListCategorised list;
            if ( !iLists.TryGetValue( descriptor.CategoryName, out list ) )
            {
                list = new DbgEntityListCategorised( Engine, descriptor );

                // We create two lists. One sorts and indexes by display order, the other indexes by category.
                iLists.Add( descriptor.CategoryName, list );
                if ( !iDisplayOrderList.ContainsKey( descriptor ) )
                {
                    iDisplayOrderList.Add( descriptor, list );
                }
            }
           
            // Add to list
            list.Add( aEntity );

            // Notify engine
            Engine.OnAdded( aEntity );
        }
        #endregion

        #region From IEnumerable<DbgEntity>
        public IEnumerator<DbgEntity> GetEnumerator()
        {
            foreach ( KeyValuePair<DbgEntityDescriptor, DbgEntityListCategorised> kvp in iDisplayOrderList )
            {
                foreach ( DbgEntity e in kvp.Value )
                {
                    yield return e;
                }
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            foreach ( KeyValuePair<DbgEntityDescriptor, DbgEntityListCategorised> kvp in iDisplayOrderList )
            {
                foreach ( DbgEntity e in kvp.Value )
                {
                    yield return e;
                }
            }
        }
        #endregion

        #region Data members
        private readonly DbgEngine iEngine;
        private SortedList<DbgEntityDescriptor, DbgEntityListCategorised> iDisplayOrderList = new SortedList<DbgEntityDescriptor, DbgEntityListCategorised>();
        private Dictionary<string, DbgEntityListCategorised> iLists = new Dictionary<string, DbgEntityListCategorised>();
        #endregion
    }
}