Untitled

package Arb;

import com.ib.client.EClientSocket;
import com.ib.client.Contract;
import com.ib.client.TickType;
import java.lang.*;
import java.io.*;
import java.util.*;

public class OrderMgr {
        public enum OrderState {
                NOT_PLACED
        }


        public class MgrOrder {
                OrderState mState = OrderState.NOT_PLACED;
                int mPrice=-1;

                public void Buy(int price)
                {
                        //TODO: send req to IB
                        mPrice = price;
                }

                public void Sell(int price)
                {
                        //TODO: send req to IB
                        mPrice = price;
                }
        }

        MgrOrder mBuys[];
        MgrOrder mSells[];

        int mDepth;
        int mMaxPosition;
        MyOrder mProto;
        int mCurrentBid;
        int mCurrentAsk;

        public OrderMgr(int depth, MyOrder prototype, int maxPosition) {
                mDepth = depth;
                mProto = prototype;
                mMaxPosition = maxPosition;
                mCurrentBid = 0;
                mCurrentAsk = 1000000000;

                mBuys = new MgrOrder[depth];
                mSells = new MgrOrder[depth];

                for(int i=0; i < depth; i++)
                {
                        mBuys[i] = new MgrOrder();
                        mSells[i] = new MgrOrder();
                }
        }

        //Prices in ticks
        public void Update(int bid, int ask)
        {
                mCurrentBid=bid;
                mCurrentAsk=ask;

                Update();
        }

        public void UpdateOrderState()
        {
                //TODO: update the order states
                Update();
        }

        public int[] GetStates()
        {
                int ret[] = new int[mDepth*2];
                for(int i=0; i < mDepth; i++)
                {
                        ret[i] = mSells[i].mPrice;
                        ret[mDepth+i] = mBuys[i].mPrice;
                }
                return ret;
        }

        //TODO: mPrice isn't good enough! need to check all possible prices the order could have
        boolean checkBuy(int price)
        {
                for(int i=0; i < mDepth; i++)
                        if(mSells[i].mPrice <= price && mSells[i].mPrice!=-1)
                                return false;
                return true;
        }

        //TODO: mPrice isn't good enough! need to check all possible prices the order could have
        boolean checkSell(int price)
        {
                for(int i=0; i < mDepth; i++)
                        if(mBuys[i].mPrice >= price && mBuys[i].mPrice!=-1)
                                return false;
                return true;
        }

        public void Update()
        {
                //TODO: we can't issue bid/ask movements that would cause self ordering
                //so one half of this will have to wait until the orders are acked on the other side

                //Any current bids above bid must be moved to bid or below if possible
                ArrayList<MgrOrder> canMove = new ArrayList<MgrOrder>();
                for(int i=0; i < mDepth; i++)
                {
                        MgrOrder order = mBuys[i];
                        if(order.mPrice>mCurrentBid||order.mPrice<mCurrentBid-(mDepth-1))
                                canMove.add(order);
                }

                for(int i=0; i < canMove.size(); i++)
                {
                        MgrOrder order = canMove.get(i);
                        int bid = 0;
                        for(int j=0; j < mDepth; j++)
                        {
                                bid = mCurrentBid-j;
                                boolean found=false;
                                for(int k=0; k < mDepth; k++)
                                {
                                        if(mBuys[k].mPrice==bid)
                                        {
                                                found=true;
                                                break;
                                        }
                                }
                                if(!found)
                                        break;
                        }
                        //Bid has the new target price
                        if(checkBuy(bid))
                                order.Buy(bid);
                }

                //Any current asks must be moved above or to the current ask
                canMove = new ArrayList<MgrOrder>();
                for(int i=0; i < mDepth; i++)
                {
                        MgrOrder order = mSells[i];
                        if(order.mPrice<mCurrentAsk||order.mPrice>mCurrentAsk+(mDepth-1))
                                canMove.add(order);
                }

                for(int i=0; i < canMove.size(); i++)
                {
                        MgrOrder order = canMove.get(i);
                        int ask = 0;
                        for(int j=0; j < mDepth; j++)
                        {
                                ask = mCurrentAsk+j;
                                boolean found=false;
                                for(int k=0; k < mDepth; k++)
                                {
                                        if(mSells[k].mPrice==ask)
                                        {
                                                found=true;
                                                break;
                                        }
                                }
                                if(!found)
                                        break;
                        }

                        //Ask has the new target price
                        if(checkSell(ask))
                                order.Sell(ask);
                }


        }

};