/*
    *  
    *  author nambi sankaran
    *  copyright (C) 2009 nambi sankaran.
    *
    *  This program is free software: you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation, either version 3 of the License, or
    *  (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
   *
   */
  package net.sf.emarket.trade.domain;
  
  import java.util.ArrayList;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeMap;
  
  import net.sf.emarket.order.domain.Order;
  import net.sf.emarket.quote.domain.Quote;
  import net.sf.emarket.trade.service.WrongSymbolException;
  
  /***
   * <code>OrderBook</code> arranges the orders according to their price, in their precedence.
   *
   * <pre>
   * buy size     price     sell size
   * ---------------------------------------
   *               31.8      20
   *               31.7      3
   *               31.6      8
   *               31.5      
   *               31.4      10
   *  5            31.3
   *  20           31.2
   *  40           31.1
   * </pre>
   *
   * @author nambi sankaran
   */
  public class OrderBook {
  	
      /*** instrument for the book */
      private String symbol;
  
      /*** limit orders */
      private Map<Float,PriceEntry> limitOrders = new TreeMap<Float,PriceEntry>();
  
      /*** market orders */
      private PriceEntry marketOrders = new PriceEntry(0f);
      
      public OrderBook( String symbol){
      	this.symbol =symbol;
      }
      
      public String getSymbol(){
      	return symbol;
      }
      
      public void loadOrders( List<ReceivedOrder> orders ){
      	
      	for( ReceivedOrder order : orders){
      		
      		// limit orders form the basis of order book
              if( order.getPriceType().equals(Order.PRICE_TYPE_LIMIT) ){
              	
                  Float price = new Float( order.getLimitPrice() );
  
                  if( limitOrders.containsKey( price )){
                      PriceEntry entry = limitOrders.get(price);
                      entry.add( order );
                  } else{
                      PriceEntry entry = new PriceEntry( order.getLimitPrice() );
                      entry.add( order );
                      limitOrders.put( price, entry );
                  }
                  
              }else{
              	// add the market orders
              	marketOrders.add(order);
              }
      	}
      	
      }
      
      public Quote getQuote( Quote quote ){
      	
      	Quote q = getQuote();
      	
      	if( !quote.getSymbol().equalsIgnoreCase(getSymbol())){
     		// POSSIBLE: this method will be always called by the "matching engine", 
     		// i.e., this is internal to eMarket
     		// so, silently return the same quote object.
     		return quote;
     		//throw new WrongSymbolException("OrderBook does not belong to symbol : "+ quote.getSymbol() );
     	}
     	
     	// some values may be different, from the quote generated from OrderBook
     	if( q.getAskPrice() != 0 && 
     			( q.getAskPrice() != quote.getAskPrice() ) ){
     		quote.setAskPrice(q.getAskPrice());
     	}
     	if( q.getAskSize() != 0 && 
     			( q.getAskSize() != quote.getAskSize() ) ){
     		quote.setAskSize(q.getAskSize());
     	}
     	
     	if( q.getBidPrice() != 0 && 
     			( q.getBidPrice() != quote.getBidPrice() ) ){
     		quote.setBidPrice(q.getBidPrice());
     	}
     	if( q.getBidSize() != 0 && 
     			( q.getBidSize() != quote.getBidSize() ) ){
     		quote.setBidSize(q.getBidSize());
     	}
 
         // get volume
 
         // set change
     	
     	return quote;
     }
     
     public Quote getQuote(){
     	
     	Quote quote = new Quote();
     	
     	quote.setSymbol(symbol);
     	
     	// this set has all prices, and it is sorted in ascending order
     	List<Float> prices = new ArrayList<Float>( limitOrders.keySet());
     	
     	// find the highest buy price.
     	for( int i= (prices.size()-1)  ; i>=0; i--){
     		Float price = prices.get(i);
     		PriceEntry entry = limitOrders.get(price);
     		
     		if( entry.hasBuyOrders() ){
     			// set the buy price for quote
     			quote.setBidPrice(price.floatValue());
     			quote.setBidSize(entry.getBuyQuantity());
     			break;
     		}
     	}
     	
     	
     	// find lowest selling price
     	for( int i= 0 ; i< prices.size() ; i++ ){
     		Float price = prices.get(i);
     		PriceEntry entry = limitOrders.get(price);
     		
     		if( entry.hasSellOrders() ){
     			// set the buy price for quote
     			quote.setAskPrice( price.floatValue() );
     			quote.setAskSize( entry.getSellQuantity() );
     			break;
     		}
     	}    	
     	return quote;
     }
     
     public List<PriceDepth> getBuyPriceDepths(int level ){
     	
     		List<PriceDepth> depths = new ArrayList<PriceDepth>(level);
     		
     		List<Float> prices = new ArrayList<Float>( limitOrders.keySet());
     		
     		int levelcount=1;
     		for( Float price : prices ){
     			
     			PriceEntry entry = limitOrders.get(price);
     			
     			if( entry.hasBuyOrders()){
     			
 		    			PriceDepth depth = new PriceDepth();
 		    			depth.setPrice(price);
 		    			depth.setNoOfOrders(entry.getTotalBuyOrders());
 		    			depth.setQuantity(entry.getTotalBuyQuantity());
 		    			
 		    			depths.add(depth);
 		    			
 		    			if( levelcount== level){
 		    				break;
 		    			}
 		    			
 		    			levelcount++;
     			}
     		}
     		
     		return depths;
     }
     
     public List<PriceDepth> getSellPriceDepths(int level ){
     	
 		List<PriceDepth> depths = new ArrayList<PriceDepth>();
 		
 		List<Float> prices = new ArrayList<Float>( limitOrders.keySet());
 		
 		int levelcount=1;
 		for( int i=(prices.size()-1); i>=0 ; i-- ){
 			
 			Float price = prices.get(i);
 			
 			PriceEntry entry = limitOrders.get(price);
 			
 			if( entry.hasSellOrders() ){
 			
 					PriceDepth depth = new PriceDepth();
 					depth.setPrice(price);
 					depth.setNoOfOrders(entry.getTotalSellOrders());
 					depth.setQuantity(entry.getTotalSellQuantity());
 					
 					depths.add(depth);
 					
 					if( levelcount== level){
 						break;
 					}
 					
 					levelcount++;
 			}
 		}
 		
 		return depths;
 }    
     
     /***
      * <code>findMatchingOrders</code> creates a list of matching orders from order book.
      * If there are no matches, the list is empty.
      * The list simply contains a list of orders, that contains the list of matching orders.
      * This method doesn't take care of partial matches.
      * 
      * @param order
      * @return
      */
     public int findMatchingOrders( ReceivedOrder order, List<ReceivedOrder> matchedOrders){
     	
     	int remainingQuantity = order.getQuantity();
     	int matchedQuantity = 0;
     	
     	List<Float> prices = new ArrayList<Float>( limitOrders.keySet());
     	
     	// if the order is "buy", get the matching "sell" orders
     	if( order.isBuy() ){
     		
     		if( order.isMarketOrder() ){
     					
     			// since this is a "buy" order, find the orders with  lowest selling prices
     			for( int i=0; i<prices.size(); i++){
     				
     				Float price = prices.get(i);
     				PriceEntry entry = limitOrders.get(price);
     				
     				// check whether this price has any sell orders
     				if( entry.hasSellOrders() ){
     					if( entry.getTotalSellQuantity() >= 0  ){
     						
     						int q = entry.getSellOrdersForQuantity(remainingQuantity, matchedOrders );
     						remainingQuantity -= q;
     						matchedQuantity += q;
     						
     						if( remainingQuantity <= 0 ){
     							break;
     						}
     					}
     				}	
     			}
     			
     		}else if( order.isLimitOrder() ){
     			
     			// in an order driver market, limit order must satisfy the limit price
     			// TODO: in a Quote driven market, buy limit price can be matched against a quote from market maker
     			if( prices.contains( order.getLimitPrice() )){
     				PriceEntry entry = limitOrders.get(order.getLimitPrice());
     				
     				if( entry.getTotalSellQuantity() > 0 ){
     					int q = entry.getSellOrdersForQuantity(remainingQuantity, matchedOrders);
     					remainingQuantity -= q;
     					matchedQuantity += q;
     				}
     			}
     		}
     		
     	}else if( order.isSell() ){
     		
     		if( order.isMarketOrder() ){
 				
     			// FIXME: since this is a "buy" order, find the orders with  lowest selling prices
     			for( int i=0; i<prices.size(); i++){
     				
     				Float price = prices.get(i);
     				PriceEntry entry = limitOrders.get(price);
     				
     				// check whether this price has any sell orders
     				if( entry.hasBuyOrders() ){
     					if( entry.getTotalBuyQuantity() >= 0  ){
     						
     						int q = entry.getSellOrdersForQuantity(remainingQuantity, matchedOrders );
     						remainingQuantity -= q;
     						matchedQuantity += q;
     						
     						if( remainingQuantity <= 0 ){
     							break;
     						}
     					}
     				}	
     			}
     			
     		}else if( order.isLimitOrder() ){
 
     			// in an order driver market, limit order must satisfy the limit price
     			// TODO: in a Quote driven market, buy limit price can be matched against a quote from market maker
     			if( prices.contains( order.getLimitPrice() )){
     				PriceEntry entry = limitOrders.get(order.getLimitPrice());
     				
     				if( entry.getTotalBuyQuantity() > 0 ){
     					int q = entry.getBuyOrdersForQuantity(remainingQuantity, matchedOrders);
     					remainingQuantity -= q;
     					matchedQuantity += q;
     				}
     			}    			
     		}
     		
     	}
     	
     	
     	return matchedQuantity;
     }
     
     //PriceComparator
     public static Comparator<? super Order> limitPriceComparator = new Comparator<Order>(){
         public int compare( Order o1, Order o2 ){
             return (int) (o1.getLimitPrice() - o2.getLimitPrice());
         }
     };
 
     //TimeComparator
     public static Comparator<Order> timeComparator = new Comparator<Order>() {
         public int compare( Order o1, Order o2 ){
             return (int) o1.getCreationTime().compareTo(o2.getCreationTime() );
         }
     };
 
 }