trading sim/account manager

using System;
using System.Collections.Generic;
using QuantSys.MarketData;
using QuantSys.TradeEngine.Simulation.Account;
using QuantSys.TradeEngine.Simulation.Account.Order;
using QuantSys.TradeEngine.Simulation.Performance;
using QuantSys.Visualization.Highstocks;

namespace QuantSys.TradeEngine.AccountManagement
{

    public class AccountManager : IAccountManager
    {
        public Portfolio Portfolio { get { return _portfolio; } }
        public List<HighstockFlag> Flags { get { return _flags; } }
        public List<double> Trades { get { return _tradeProfits; } }
        public double CurrentBalance { get { return _portfolio.CurrentBalance; } }
        public double CurrentEquity { get { return _portfolio.CurrentEquity; } }

        private BacktestPerformance _performance;

        private readonly Portfolio _portfolio;

        private Dictionary<Symbol, StopOrder> _outStandingStopOrders;
        private Dictionary<Symbol, LimitOrder> _outStandingLimitOrders;

        private List<HighstockFlag> _flags;
        private List<double> _tradeProfits;

        private Dictionary<Symbol, Tick> currentOffers;
        public AccountManager()
        {
            _portfolio = new Portfolio();
            _flags = new List<HighstockFlag>();
            _outStandingStopOrders = new Dictionary<Symbol, StopOrder>();
            _outStandingLimitOrders = new Dictionary<Symbol, LimitOrder>();
            _tradeProfits = new List<double>();
            _performance = new BacktestPerformance();
            currentOffers = new Dictionary<Symbol, Tick>();
        }

        #region StopOrder Logic

        public StopOrder GetStopOrder(Symbol s)
        {
            if (_outStandingStopOrders.ContainsKey(s))
            {
                return _outStandingStopOrders[s];
            }

            return null;
        }
        public void PlaceStopOrder(StopOrder stop)
        {
            _outStandingStopOrders.Add(stop.Symbol, stop);
        }
        public void ModifyStopOrder(Tick stop, double newPrice)
        {
            if (_outStandingStopOrders.ContainsKey(stop.Symbol))
            {
                _outStandingStopOrders[stop.Symbol].TriggerPrice = newPrice;
            }



        }
        private void CloseStopOrder(Tick t, StopOrder s)
        {
            _tradeProfits.Add(_portfolio.ClosePosition(t, s.TriggerPrice));

            _outStandingStopOrders.Remove(s.Symbol);



            if (_outStandingLimitOrders.ContainsKey(t.Symbol))
                _outStandingLimitOrders.Remove(t.Symbol);



            _flags.Add(new HighstockFlag(
                                "CS",
                                "Closed Stop Order",
                                t.Time
                            ));
        }

        public void ModifyTrailingStop(Tick stop, double trailSize)
        {
            if (_outStandingStopOrders.ContainsKey(stop.Symbol))
            {
                _outStandingStopOrders[stop.Symbol].Trailing = true;
                _outStandingStopOrders[stop.Symbol].TrailSize = trailSize;
            }
        }
        #endregion


        #region LimitOrder Logic

        public LimitOrder GetLimitOrder(Symbol s)
        {
            if (_outStandingLimitOrders.ContainsKey(s))
            {
                return _outStandingLimitOrders[s];
            }

            return null;
        }

        public void PlaceLimitOrder(LimitOrder limit)
        {
            _outStandingLimitOrders.Add(limit.Symbol, limit);
        }

        public void ModifyLimitOrder(Tick limit, double newPrice)
        {
            if (_outStandingLimitOrders.ContainsKey(limit.Symbol))
            {
                _outStandingLimitOrders[limit.Symbol].TriggerPrice = newPrice;
            }
        }

        private void CloseLimitOrder(Tick t, LimitOrder l)
        {
            _tradeProfits.Add(_portfolio.ClosePosition(t, l.TriggerPrice));

            _outStandingLimitOrders.Remove(l.Symbol);


            if (_outStandingStopOrders.ContainsKey(t.Symbol))
                _outStandingStopOrders.Remove(t.Symbol);



            _flags.Add(new HighstockFlag(
                                "CL",
                                "Closed Limit Order",
                                t.Time
                            ));
        }

        private void ModifyTrailingLimit(double trailSize)
        {
            throw new NotImplementedException();
        }

        #endregion

        public void IncreasePosition(Symbol t, double size)
        {
            if (!currentOffers.ContainsKey(t)) return;
            _portfolio.IncreasePosition(currentOffers[t], size);
        }

        public void ReducePosition(Symbol t, double size)
        {
            if (!currentOffers.ContainsKey(t)) return;
            _portfolio.ReducePosition(currentOffers[t], size);
        }

        public void ClosePosition(Symbol s)
        {
            if (!currentOffers.ContainsKey(s)) return;
            Tick t = currentOffers[s];

            _tradeProfits.Add(_portfolio.ClosePosition(t,
                (_portfolio.Positions[t.Symbol].isLong ? t.BidClose : t.AskClose)));


            if (_outStandingStopOrders.ContainsKey(t.Symbol))
                _outStandingStopOrders.Remove(t.Symbol);

            if (_outStandingLimitOrders.ContainsKey(t.Symbol))
                _outStandingLimitOrders.Remove(t.Symbol);


            _flags.Add(new HighstockFlag(
                                "C",
                                "Closed Order",
                                t.Time
                            ));
        }


        public void OnTick(params Tick[] ticks)
        {


            foreach (Tick t in ticks)
            {
                if (!currentOffers.ContainsKey(t.Symbol))
                    currentOffers.Add(t.Symbol, t);
                else
                    currentOffers[t.Symbol] = t;
            }

            foreach (Tick t in ticks)
            {


                if (_outStandingStopOrders.ContainsKey(t.Symbol))
                {
                    StopOrder stopOrder = _outStandingStopOrders[t.Symbol];


                    if (stopOrder.Trailing) stopOrder.RecalculateTrail(t);


                    if (stopOrder.IsBuyStop())
                    {

                        if (t.BidLow <= stopOrder.TriggerPrice)
                        {
                            CloseStopOrder(t, stopOrder);
                        }
                    }


                    else if (stopOrder.IsSellStop())
                    {
                        if (t.AskHigh >= stopOrder.TriggerPrice)
                        {
                            CloseStopOrder(t, stopOrder);

                        }
                    }
                }




                if (_outStandingLimitOrders.ContainsKey(t.Symbol))
                {
                    LimitOrder limitOrder = _outStandingLimitOrders[t.Symbol];


                    if (limitOrder.Trailing) limitOrder.RecalculateTrail(t);


                    if (limitOrder.IsBuyLimit())
                    {

                        if (t.BidClose >= limitOrder.TriggerPrice)
                        {
                            CloseLimitOrder(t, limitOrder);
                        }
                    }


                    else if (limitOrder.IsSellLimit())
                    {
                        if (t.AskClose <= limitOrder.TriggerPrice)
                        {
                            CloseLimitOrder(t, limitOrder);
                        }
                    }
                }

            }



            _portfolio.AdjustPortfolioEquityAndMargin(ticks);

        }


        public bool ExistsPositionForSymbol(Symbol s)
        {
            return _portfolio.ExistsPositionForSymbol(s);
        }

        public bool ExistsLongPositionForSymbol(Symbol s)
        {
            return _portfolio.ExistsPositionForSymbol(s) && _portfolio[s].Side.Equals(Position.PositionSide.Long);
        }

        public bool ExistsShortPositionForSymbol(Symbol s)
        {
            return _portfolio.ExistsPositionForSymbol(s) && _portfolio[s].Side.Equals(Position.PositionSide.Short);
        }


        public void PlaceMarketOrder(Symbol sym, int size, Position.PositionSide side, double stopPips = double.NaN, double LimitPips = double.NaN)
        {
            if (!currentOffers.ContainsKey(sym)) return;

            double orderPrice = side.Equals(Position.PositionSide.Long)
                ? currentOffers[sym].AskClose
                : currentOffers[sym].BidClose;


            _portfolio.TakePosition(sym, orderPrice, side, size, currentOffers[sym].Time);


            if (!stopPips.Equals(double.NaN))
            {
                StopOrder stopOrder = new StopOrder(sym, side, ((side.Equals(Position.PositionSide.Long)) ? orderPrice - stopPips : orderPrice + stopPips));
                PlaceStopOrder(stopOrder);
            }

            if (!LimitPips.Equals(double.NaN))
            {
                LimitOrder limitOrder = new LimitOrder(sym, side, ((side.Equals(Position.PositionSide.Long)) ? orderPrice + LimitPips : orderPrice - LimitPips));
                PlaceLimitOrder(limitOrder);
            }


            _flags.Add(new HighstockFlag(
                    (side == Position.PositionSide.Long) ? "B" : "S",
                    ((side == Position.PositionSide.Long) ? "Bought " : "Sold ") + size + " on " + side + " at " + orderPrice + " on " + currentOffers[sym].Time.ToString(),
                    currentOffers[sym].Time
                ));

        }

        public void ModifyStopOrder()
        {
            throw new NotImplementedException();
        }

        public void SetTrailingStop()
        {
            throw new NotImplementedException();
        }

        public void PlaceStopOrder()
        {
            throw new NotImplementedException();
        }

    }
}