/*
* 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.Collections.Generic;
using System.Reflection;
using System.ComponentModel;

namespace CrashItemLib.Crash.Base.DataBinding
{
    public class CIDBModel : IEnumerable<CIDBRow>
	{
		#region Constructors
        public CIDBModel( CIElement aElement, bool aAutoPopulate )
        {
            iElement = aElement;
            iAutoPopulate = aAutoPopulate;
        }
		#endregion

        #region API
        public void Add( CIDBColumn aColumn )
        {
            aColumn.Model = this;
            iColumns.Add( aColumn );
        }

        public void Add( CIDBRow aRow )
        {
            aRow.Model = this;
            iRows.Add( aRow );
        }

        public void Add( params CIDBCell[] aCells )
        {
            CIDBRow row = new CIDBRow( aCells );
            Add( row );
        }

        public void ClearRows()
        {
            iRows.Clear();
        }

        public void ClearColumns()
        {
            iColumns.Clear();
        }

        public void TryAutoPopulateColumns( CIElement aElement )
        {
            Type customAttributeType = typeof( CIDBAttributeColumn );
            Type thisObjectType = aElement.GetType();

            object[] attribs = thisObjectType.GetCustomAttributes( customAttributeType, true );
            if ( attribs != null && attribs.Length > 0 )
            {
                ExtractAttributeColumns( attribs, aElement );
            }
        }

        public void TryAutoPopulateCells( CIElement aElement )
        {
            if ( AutoPopulate )
            {
                SortedDictionary<int, CIDBRow> rows = new SortedDictionary<int, CIDBRow>();
                
                Type customAttributeType = typeof( CIDBAttributeCell );
                Type thisObjectType = aElement.GetType();

                // Get properties featuring the CIDBAttribute 
                PropertyInfo[] propertyInfo = thisObjectType.GetProperties();
                foreach ( PropertyInfo p in propertyInfo )
                {
                    object[] attribs = p.GetCustomAttributes( customAttributeType, true );
                    if ( attribs != null && attribs.Length > 0 )
                    {
                        object propertyValue = p.GetValue( aElement, null );
                        ExtractAttributeCells( p.ToString(), aElement, attribs, propertyValue, rows );
                    }
                }

                // Same, but get methods featuring the CIDBAttribute 
                MethodInfo[] methodInfo = thisObjectType.GetMethods();
                foreach ( MethodInfo m in methodInfo )
                {
                    object[] attribs = m.GetCustomAttributes( customAttributeType, true );
                    if ( attribs != null && attribs.Length > 0 )
                    {
                        // We only support this attribute on methods that don't contain
                        // any arguments
                        int paramCount = m.GetParameters().Length;
                        if ( paramCount != 0 )
                        {
                            throw new NotSupportedException( "Method: " + m.ToString() + " has CIDBAttribute but non-empty parameter list -> Not supported" );
                        }

                        // Get property value 
                        object propertyValue = m.Invoke( aElement, null );
                        ExtractAttributeCells( m.ToString(), aElement, attribs, propertyValue, rows );
                    }
                }

                // Since the list is already sorted for us, just add the items in order
                foreach ( KeyValuePair<int, CIDBRow> kvp in rows )
                {
                    this.Add( kvp.Value );
                }
            }
        }
        #endregion

        #region Properties
        public bool AutoPopulate
        {
            get { return iAutoPopulate; }
        }

        public CIElement Element
        {
            get { return iElement; }
        }

        public List<CIDBColumn> Columns
        {
            get { return iColumns; }
        }

        public List<CIDBRow> Rows
        {
            get { return iRows; }
        }
        #endregion

        #region Internal methods
        private void ExtractAttributeColumns( object[] aColumnAttributes, CIElement aElement )
        {
            bool foundColumnAttributes = false;
            SortedDictionary<int, CIDBColumn> columns = new SortedDictionary<int,CIDBColumn>();

            foreach ( object obj in aColumnAttributes )
            {
                if ( obj is CIDBAttributeColumn )
                {
                    CIDBAttributeColumn attribute = (CIDBAttributeColumn) obj;

                    // Make a column
                    CIDBColumn col = new CIDBColumn( attribute.Caption );
                    col.Width = attribute.Width;
                    col.WidthSet = attribute.WidthSet;
                    col.TakesUpSlack = attribute.TakesUpSlack;

                    if ( columns.ContainsKey( attribute.Order ) )
                    {
                        throw new Exception( string.Format( "Column: [{0}] in element: [{1}] specifies order: {2} which is already in use",
                                                            attribute.Caption, aElement, attribute.Order ) );
                    }

                    columns.Add( attribute.Order, col );
                    foundColumnAttributes = true;
                }
            }

            // Since the list is already sorted for us, just add the items in order
            foreach ( KeyValuePair<int, CIDBColumn> kvp in columns )
            {
                this.Add( kvp.Value );
            }

            // We'll override the auto populate feature if we find a valid
            // column attribute
            iAutoPopulate = foundColumnAttributes;
        }

        private void ExtractAttributeCells( string aEntityName, CIElement aElement, object[] aCIDBAttributeEntries, object aValue, SortedDictionary<int, CIDBRow> aRows )
        {
            foreach ( object obj in aCIDBAttributeEntries )
            {
                if ( obj is CIDBAttributeCell )
                {
                    CIDBAttributeCell attribute = (CIDBAttributeCell) obj;

                    // If the property is an 'auto expand' entry, then don't look at this
                    // property, but instead look at the object itself
                    if ( attribute.Options == CIDBAttributeCell.TOptions.EAutoExpand )
                    {
                        // The object must be an element
                        CIElement element = aValue as CIElement;
                        if ( element == null )
                        {
                            throw new ArgumentException( "CIDBAttributeCell(TOptions.EAutoExpand) may only be applied to CIElement objects" );
                        }

                        TryAutoPopulateCells( element );
                    }
                    else
                    {
                        // Whether or not to create a row
                        bool makeRow = true;

                        // Convert attribute value to string. If the object is an enum, we'll check if it has
                        // a System.ComponentModel.Description attached to it, and use that in preference to a raw
                        // value.
                        string defaultValueString = ( attribute.DefaultValue != null ) ? attribute.DefaultValue.ToString() : null;
                        string propertyValueString = aValue.ToString();
                        if ( aValue.GetType().BaseType == typeof( Enum ) )
                        {
                            // Check if it supports System.ComponentModel.Description
                            FieldInfo fi = aValue.GetType().GetField( propertyValueString );
                            if ( fi != null )
                            {
                                DescriptionAttribute[] attributes = (DescriptionAttribute[]) fi.GetCustomAttributes( typeof( DescriptionAttribute ), false );
                                if ( attributes != null && attributes.Length > 0 )
                                {
                                    propertyValueString = attributes[ 0 ].Description;
                                }
                            }
                        }
                        else if ( attribute.Format.Length > 0 && aValue is IFormattable )
                        {
                            string formatSpec = attribute.Format;
                            IFormattable formattable = (IFormattable) aValue;
                            propertyValueString = formattable.ToString( formatSpec, null );

                            // Also get the default value if available
                            bool defaultIsFormattable = attribute.DefaultValue is IFormattable;
                            if ( attribute.DefaultValue != null && defaultIsFormattable )
                            {
                                formattable = (IFormattable) attribute.DefaultValue;
                                defaultValueString = formattable.ToString( formatSpec, null );
                            }
                        }

                        // If the value of the property is the same as the default, then don't
                        // show it.
                        if ( defaultValueString != null )
                        {
                            makeRow = ( defaultValueString.CompareTo( propertyValueString ) != 0 );
                        }

                        // Make a row
                        if ( makeRow )
                        {
                            CIDBRow row = new CIDBRow();
                            row.Add( new CIDBCell( attribute.Caption ) );
                            row.Add( new CIDBCell( propertyValueString, attribute.ForeColor, attribute.BackColor, attribute.Format ) );

                            // Add the row if it doesn't exist. If it does, then that implies
                            // duplicate ordering, which we treat as a programming error.
                            if ( aRows.ContainsKey( attribute.Order ) )
                            {
                                throw new Exception( string.Format( "Entity: [{0}] in element: [{1}] specifies order: {2} which is already in use",
                                                                    aEntityName, aElement, attribute.Order ) );
                            }

                            aRows.Add( attribute.Order, row );
                        }
                    }
                }
            }
        }
        #endregion

        #region From IEnumerable<CIDBRow>
        public IEnumerator<CIDBRow> GetEnumerator()
        {
            foreach ( CIDBRow row in iRows )
            {
                yield return row;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            foreach ( CIDBRow row in iRows )
            {
                yield return row;
            }
        }
        #endregion

        #region Data members
        private readonly CIElement iElement;
        private bool iAutoPopulate = false;
        private List<CIDBColumn> iColumns = new List<CIDBColumn>();
        private List<CIDBRow> iRows = new List<CIDBRow>();
		#endregion
    }
}