/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
*   this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
*   this list of conditions and the following disclaimer in the documentation
*   and/or other materials provided with the distribution.
* - Neither the name of Nokia Corporation nor the names of its contributors
*   may be used to endorse or promote products derived from this software
*   without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* 
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using HeapLib.Cells;
using HeapLib.Relationships;

namespace HeapUiLib.Controls
{
    public partial class HeapCellViewerControl : UserControl
    {
        #region Events
        public delegate void OnCellLinkDoubleClicked( HeapCell aCell );
        public event OnCellLinkDoubleClicked CellLinkDoubleClicked;
        #endregion

        #region Constructors & destructor
        public HeapCellViewerControl()
        {
            InitializeComponent();
        }
        #endregion

        #region Properties
        [Browsable(false)]
        public HeapCell Cell
        {
            get { return iCell; }
            set
            {
                // This will asynchronously redraw the table
                iCell = value;
                DisplayRawDataItemIndex = 0;
            }
        }
        #endregion

        #region Event handlers
        private void iTimerRefresh_Tick( object sender, EventArgs e )
        {
            iTimerRefresh.Enabled = false;
            iTimerRefresh.Stop();
            //
            UpdateTable();
        }

        private void iTable_RawItems_CellDoubleClick( object sender, XPTable.Events.CellMouseEventArgs e )
        {
            if ( e.Cell.Tag != null && e.Cell.Tag is HeapCell )
            {
                HeapCell linkedCell = (HeapCell) e.Cell.Tag;
                //
                if ( CellLinkDoubleClicked != null )
                {
                    CellLinkDoubleClicked( linkedCell );
                }
            }
        }

        private void iButton_PageUp_Click( object sender, EventArgs e )
        {
            HeapCell selectedCell = Cell;
            if ( selectedCell != null )
            {
                DisplayRawDataItemIndex -= KNumberOfRowsPerPage;
            }
        }

        private void iButton_PageDown_Click( object sender, EventArgs e )
        {
            HeapCell selectedCell = Cell;
            if ( selectedCell != null )
            {
                DisplayRawDataItemIndex += KNumberOfRowsPerPage;
            }
        }
        #endregion

        #region Internal properties
        private int DisplayRawDataItemIndex
        {
            get { return iDisplayRawDataItemIndex; }
            set
            {
                iDisplayRawDataItemIndex = value;
                //
                SetPageUpButtonStatus();
                SetPageDownButtonStatus();
                //
                RefreshContentsByTimer();
            }
        }
        #endregion

        #region Internal methods
        private void UpdateTable()
        {
            HeapCell cell = Cell;
            //
            iTable_RawItems.BeginUpdate();
            iTableModel.Rows.Clear();
            //            
            if ( cell != null )
            {
                // Work out our raw item offset and how many raw items to create in this operation
                SymbianUtils.RawItems.RawItemCollection rawItems = cell.RawItems;
                int rawItemIndexStart = DisplayRawDataItemIndex;
                int rawItemIndexEnd = Math.Min( rawItems.Count, rawItemIndexStart + KNumberOfRowsPerPage ); 
                //
                for ( int rawItemIndex = rawItemIndexStart; rawItemIndex < rawItemIndexEnd; rawItemIndex++ )
                {
                    SymbianUtils.RawItems.RawItem rawEntry = rawItems[ rawItemIndex ];
                    XPTable.Models.Row row = new XPTable.Models.Row();

                    // Cell 1: address
                    XPTable.Models.Cell cellAddress = new XPTable.Models.Cell( rawEntry.Address.ToString( "x8" ) );

                    // Cell 2: raw data
                    XPTable.Models.Cell cellRawData = new XPTable.Models.Cell( rawEntry.OriginalData.ToString( "x8" ) );

                    // Cell 3: interpreted data
                    XPTable.Models.Cell cellInterpretedData = new XPTable.Models.Cell( rawEntry.Data.ToString( "x8" ) );

                    // Cell 4: characterised data
                    XPTable.Models.Cell cellCharacterisedData = new XPTable.Models.Cell( rawEntry.OriginalCharacterisedData );

                    // Update style of "interpreted data" if there is a link to another cell. 
                    RelationshipInfo relationshipDescriptor = ( rawEntry.Tag != null && rawEntry.Tag is RelationshipInfo ) ? (RelationshipInfo) rawEntry.Tag : null;
                    if ( relationshipDescriptor != null )
                    {
                        // The colour depends on whether it is a clean link or not. Clean means whether or not the
                        // link points to the start of the specified cell.
                        HeapCell linkedCell = relationshipDescriptor.ToCell;
                        //
                        if ( relationshipDescriptor.IsCleanLink )
                        {
                            cellInterpretedData.ForeColor = Color.Blue;
                            cellInterpretedData.ToolTipText = "Link to start of: " + linkedCell.SymbolString + " @ 0x" + linkedCell.Address.ToString( "x8" );
                        }
                        else
                        {
                            cellInterpretedData.ForeColor = Color.DarkBlue;
                            cellInterpretedData.ToolTipText = "Link within: " + linkedCell.SymbolString + " @ 0x" + linkedCell.Address.ToString( "x8" );
                        }

                        cellInterpretedData.Font = new Font( iTable_RawItems.Font, FontStyle.Underline );
                        cellInterpretedData.Tag = linkedCell;
                    }

                    // Finish construction
                    row.Cells.Add( cellAddress );
                    row.Cells.Add( cellRawData );
                    row.Cells.Add( cellInterpretedData );
                    row.Cells.Add( cellCharacterisedData );
                    iTableModel.Rows.Add( row );
                }
            }

            // Try to select first item
            if ( iTable_RawItems.TableModel.Rows.Count > 0 )
            {
                iTable_RawItems.EnsureVisible( 0, 0 );
                iTable_RawItems.TableModel.Selections.SelectCell( 0, 0 );
            }

            iTable_RawItems.EndUpdate();
        }

        private void RefreshContentsByTimer()
        {
            if ( iTimerRefresh.Enabled )
            {
                iTimerRefresh.Enabled = false;
                iTimerRefresh.Stop();
            }

            iTimerRefresh.Enabled = true;
            iTimerRefresh.Start();
        }

		private void SetPageUpButtonStatus()
		{
			bool enabled = false;
            HeapCell selectedCell = Cell;
            if ( selectedCell != null )
            {
                SymbianUtils.RawItems.RawItemCollection rawItems = selectedCell.RawItems;
                //
                int previousWindowStart = DisplayRawDataItemIndex - KNumberOfRowsPerPage;
                int previousWindowEnd = DisplayRawDataItemIndex;
                //
                enabled = ( previousWindowStart >= 0 );
            }
			iButton_PageUp.Enabled = enabled;
		}

		private void SetPageDownButtonStatus()
		{
			bool enabled = false;
            HeapCell selectedCell = Cell;
            if ( selectedCell != null )
            {
                SymbianUtils.RawItems.RawItemCollection rawItems = selectedCell.RawItems;
                //
                int nextWindowStart = DisplayRawDataItemIndex + KNumberOfRowsPerPage;
                int nextWindowEnd = Math.Min( rawItems.Count, nextWindowStart + KNumberOfRowsPerPage );
                //
                enabled = ( nextWindowStart < rawItems.Count );
            }
			iButton_PageDown.Enabled = enabled;
		}
        #endregion

        #region Internal constants
        private const int KNumberOfRowsPerPage = 128;
        #endregion

        #region Data members
        private HeapCell iCell = new HeapCell();
        private int iDisplayRawDataItemIndex = 0;
        #endregion
    }
}