/*
* 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.Threading;
using System.ComponentModel;
using System.Collections.Generic;
using System.IO;
using SymbianUtils.DataBuffer.Entry;
using SymbianStructuresLib.Arm.Registers;
using SymbianStructuresLib.CodeSegments;
using SymbianStructuresLib.Debug.Symbols;
using SymbianUtils;
using SymbianUtils.Range;
using SymbianUtils.Utilities;
using SymbianDebugLib.PluginAPI.Types;
using SymbianDebugLib.Engine;
using SymbianStackLib.Data.Source;
using SymbianStackLib.Data.Output;
using SymbianStackLib.Data.Output.Entry;
using SymbianStackLib.Interfaces;
using SymbianStackLib.Algorithms;

namespace SymbianStackAlgorithmBasic
{
    internal class StackAlgBasic : StackAlgorithm
    {
        #region Constructors
        public StackAlgBasic( IStackAlgorithmManager aManager, IStackAlgorithmObserver aObserver )
            : base( aManager, aObserver )
        {
        }
        #endregion

        #region API
        #endregion

        #region Properties
        #endregion

        #region From StackAlgorithm
        public override bool IsAvailable()
        {
            // This is always available
            return true;
        }

        public override string Name
        {
            get { return "Basic"; }
        }

        public override int Priority
        {
            get { return 200; }
        }
        #endregion

        #region From AsyncReaderBase
        protected override void PerformOperation()
        {
            // Get the source data we need to reconstruct and signal we're about to start
            StackSourceData sourceData = base.SourceData;

            // Get the output data sink
            StackOutputData outputData = base.OutputData;
            outputData.Clear();
            outputData.AlgorithmName = Name;

            // Get the address range of the stack pointer data
            AddressRange pointerRange = base.Engine.AddressInfo.StackPointerRange;
            AddressRange pointerRangeExtended = base.Engine.AddressInfo.StackPointerRangeWithExtensionArea;

            // Indicates if we added LR and PC to the call stack
            bool addedLRandPC = false;

            // Get registers
            ArmRegisterCollection regs = base.Engine.Registers;

            foreach ( DataBufferUint sourceEntry in sourceData.GetUintEnumerator() )
            {
                // Check if it is within the stack domain, taking into account
                // our extended range
                if ( pointerRangeExtended.Contains( sourceEntry.Address ) )
                {
                    StackOutputEntry outputEntry = new StackOutputEntry( sourceEntry.Address, sourceEntry.Uint );

                    // Is it the element tht corresponds to the current value of SP?
                    bool isCurrentSPEntry = ( outputEntry.AddressRange.Contains( base.Engine.AddressInfo.Pointer ) );
                    outputEntry.IsCurrentStackPointerEntry = isCurrentSPEntry;

                    // Is it within the pure 'stack pointer' address range?
                    bool outsidePureStackPointerRange = !pointerRange.Contains( sourceEntry.Address );
                    outputEntry.IsOutsideCurrentStackRange = outsidePureStackPointerRange;

                    // These are never accurate, but neither are they ghosts
                    outputEntry.IsAccurate = false;
                    outputEntry.IsGhost = false;

                    // Save entry
                    EmitElement( outputEntry );

                    // If we're inside the stack address range, then poke in the PC and LR values
                    if ( isCurrentSPEntry )
                    {
                        System.Diagnostics.Debug.Assert( !addedLRandPC );
                        addedLRandPC = AddLRAndPC();
                    }
                }
                else
                {
                    // Nope, ignore it...
                }

                NotifyEvent( TEvent.EReadingProgress );
                ++iDWordIndex;
            }

            // If the stack overflowed, then SP might be outside of the stack range. Therefore
            // LR and PC will not be added yet.
            if ( !addedLRandPC )
            {
                AddLRAndPC();
            }
        }

        protected override long Size
        {
            get
            {
                int bytes = base.SourceData.Count;
                int dWords = bytes / 4;
                return dWords;
            }
        }

        protected override long Position
        {
            get
            {
                return iDWordIndex;
            }
        }
        #endregion

        #region Internal methods
        private bool AddLRAndPC()
        {
            bool addedLRandPC = false;
            //
            ArmRegisterCollection regs = base.Engine.Registers;

            // If we're inside the stack address range, then poke in the PC and LR values
            if ( regs.Count > 0 )
            {
                // Working bottom up, so LR should go on the stack first
                if ( regs.Contains( TArmRegisterType.EArmReg_LR ) )
                {
                    ArmRegister regLR = regs[ TArmRegisterType.EArmReg_LR ];

                    StackOutputEntry entryLR = new StackOutputEntry( 0, regLR.Value );
                    entryLR.IsRegisterBasedEntry = true;
                    entryLR.IsOutsideCurrentStackRange = true;
                    entryLR.AssociatedRegister = regLR.RegType;
                    EmitElement( entryLR );
                }

                // Then the PC...
                if ( regs.Contains( TArmRegisterType.EArmReg_PC ) )
                {
                    ArmRegister regPC = regs[ TArmRegisterType.EArmReg_PC ];

                    StackOutputEntry entryPC = new StackOutputEntry( 0, regPC.Value );
                    entryPC.IsRegisterBasedEntry = true;
                    entryPC.IsOutsideCurrentStackRange = true;
                    entryPC.AssociatedRegister = regPC.RegType;
                    EmitElement( entryPC );
                }

                // Even if they weren't added, we at least attempted to addd them
                addedLRandPC = true;
            }

            return addedLRandPC;
        }

        private void EmitElement( StackOutputEntry aEntry )
        {
            // Flush entry
            base.StackObserver.StackBuildingElementConstructed( this, aEntry );
        }
        #endregion

        #region Data members
        private int iDWordIndex = 0;
        #endregion
    }
}