/*
    *  
    *  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.service;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import net.sf.emarket.account.service.NotEnoughCashException;
  import net.sf.emarket.account.service.NotEnoughPositionsException;
  import net.sf.emarket.account.service.NotValidAccountException;
  import net.sf.emarket.order.domain.Order;
  import net.sf.emarket.order.service.IOrderManagerService;
  import net.sf.emarket.order.service.OrderCannotBeFilledException;
  import net.sf.emarket.order.service.OrderFillQuantityMismatchException;
  import net.sf.emarket.quote.service.IQuoteManagerService;
  import net.sf.emarket.trade.domain.MarketDepth;
  import net.sf.emarket.trade.domain.OrderBook;
  import net.sf.emarket.trade.domain.OrderBookLock;
  import net.sf.emarket.trade.domain.OrderFill;
  import net.sf.emarket.trade.domain.OrderMatch;
  import net.sf.emarket.trade.domain.ReceivedOrder;
  import net.sf.emarket.trade.repository.IOrderBookDao;
  import net.sf.emarket.trade.repository.IOrderBookLockDao;
  import net.sf.emarket.trade.repository.IOrderMatchDao;
  import net.sf.emarket.trade.repository.IReceivedOrdersDao;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.dao.EmptyResultDataAccessException;
  import org.springframework.transaction.annotation.Propagation;
  import org.springframework.transaction.annotation.Transactional;
  
  class TradingServiceImpl implements ITradingService {
  
  	private static final long serialVersionUID = 499772084600054782L;
  
  	IReceivedOrdersDao receivedOrderDao = null;
  	IOrderBookDao orderBookDao = null;
  	IOrderBookLockDao orderBookLockDao = null;
  	IOrderMatchDao orderMatchDao = null;
  	
  	IQuoteManagerService quoteSvc = null;
  	IOrderManagerService orderSvc = null;
  	
  	@Autowired
  	public void setReceivedOrderDao( IReceivedOrdersDao dao){
  		receivedOrderDao = dao;
  	}
  	
  	@Autowired
  	public void setOrderBookDao( IOrderBookDao dao){
  		orderBookDao = dao;
  	}
  	
  	@Autowired
  	public void setOrderBookLockDao( IOrderBookLockDao dao){
  		orderBookLockDao = dao;
  	}
  	
  	@Autowired
  	public void setOrderMatchDao( IOrderMatchDao dao){
  		orderMatchDao = dao;
  	}
  	
  	@Autowired
  	public void setQuoteManagerService( IQuoteManagerService svc ){
  		quoteSvc = svc;
  	}
  
  	@Autowired
  	public void setOrderManagerService( IOrderManagerService svc ){
  		orderSvc = svc;
  	}
  	
  	public ReceivedOrder getReceivedOrderById( String orderId ){
  		
  		ReceivedOrder receivedOrder=null;
  		
  		try{
  			receivedOrder = receivedOrderDao.getReceivedOrder(orderId);
  		}catch(EmptyResultDataAccessException dae ){
  			receivedOrder = new ReceivedOrder();
  			receivedOrder.setProcessingStatus(ReceivedOrder.PROCESSING_STATUS_NOT_RECEIVED);
 		}
 		
 		return receivedOrder;
 	}
 	
 	public void addReceivedOrder( ReceivedOrder order){
 		receivedOrderDao.addOrder(order);
 	}
 
 	public OrderBookLock getOrderBookLockStatus(String symbol){
 		
 		OrderBookLock lock = null;
 		
 		try{
 			lock = orderBookLockDao.getLock(symbol);
 		}catch( EmptyResultDataAccessException dae ){
 			lock = new OrderBookLock();
 			lock.setSymbol(symbol);
 			lock.setStatus( OrderBookLock.UN_LOCKED);
 		}
 		
 		return lock;
 	}
 	
 	public OrderBookLock lockOrderBook( String symbol){
 		OrderBookLock lock = null;
 		
 		try{
 			
 			lock = orderBookLockDao.getLock(symbol);
 						
 		}catch(EmptyResultDataAccessException dae ){
 			lock = new OrderBookLock();
 			lock.setSymbol(symbol);
 			lock.setStatus( OrderBookLock.LOCKED);
 			orderBookLockDao.addLock(lock);
 		}
 		
 		if( 	lock.getSymbol().equals(symbol) &&
 				lock.getStatus().equals( OrderBookLock.UN_LOCKED)){
 			
 			lock.setStatus(OrderBookLock.LOCKED);
 			orderBookLockDao.updateLock(lock);
 		}else if( lock.getSymbol().equals(symbol) &&
 				lock.getStatus().equals( OrderBookLock.UN_LOCKED)){
 			// TODO: loop here until the lock is available again and throw an exception if it exceeds timeout period .
 		}
 		
 		return lock;
 	}
 	
 	
 	public void releaseOrderBook(String symbol){
 		
 		OrderBookLock lock = null;
 		
 		try{
 			
 			lock = orderBookLockDao.getLock(symbol);
 			lock.setStatus(OrderBookLock.UN_LOCKED);
 			
 			orderBookLockDao.updateLock(lock);
 			
 		}catch( EmptyResultDataAccessException dae ){
 			lock = new OrderBookLock();
 			lock.setSymbol(symbol);
 			lock.setStatus( OrderBookLock.UN_LOCKED);
 			orderBookLockDao.addLock(lock);			
 		}
 	}
 	
 	public OrderBook getOrderBook(String symbol){
 		OrderBook book = new OrderBook(symbol);
 		
 		List<ReceivedOrder> orders = getOrdersFromBook(symbol);
 		book.loadOrders(orders);
 		
 		return book;
 	}
 
 	
 	public List<ReceivedOrder> getOrdersFromBook( String symbol ){
 			return orderBookDao.getOrdersBySymbol(symbol);
 	}
 	
 	public void updateOrderBook( ReceivedOrder order ){
 		
 		try{
 			
 			ReceivedOrder o = orderBookDao.getOrderById(order.getId());			
 
 			if( o.getId().equalsIgnoreCase(order.getId())){
 				// TODO: update orderbook, if the order is already found. figure out the conditions at which it needs to be updated.
 			}
 			
 		}catch( EmptyResultDataAccessException dae ){
 			// add the order to order book
 			orderBookDao.addOrder(order);
 		}
 		
 /*		// at this point, it is possible that quote for this symbol has changed.
 		// send an update to the quote system, if there is a change.
 		OrderBook book = getOrderBook(order.getSymbol());
 		
 		Quote q = quoteSvc.getQuote(order.getSymbol());
 		Quote quote = book.getQuote(q);
 		quoteSvc.updateQuote(quote);*/
 		
 	}
 
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public void updateOrderBook( ReceivedOrder receivedOrder, List<OrderMatch> matches, int matchedQuantity ){
 		
 
 		int remainingQuantity = receivedOrder.getQuantity() - matchedQuantity;
 		if( remainingQuantity >0 ){
 			receivedOrder.setQuantity(remainingQuantity);
 			orderBookDao.updateOrder(receivedOrder);
 		}else if( remainingQuantity == 0 ){
 			orderBookDao.deleteOrder(receivedOrder);
 		}
 		
 		for( OrderMatch match : matches ){
 			
 			ReceivedOrder order =null;
 			
 			if( receivedOrder.isBuy() ){
 				
 				// Buy order
 				order = orderBookDao.getOrderById(match.getSellOrderId());
 				if(match.getSellMatchType().equals(OrderMatch.TYPE_FULL)){
 					orderBookDao.deleteOrder(order);
 				}else if( match.getSellMatchType().equals(OrderMatch.TYPE_PARTIAL) ){
 					// update the quantity in OrderBook
 					int remaining = order.getQuantity() - match.getMatchedQuantity();
 					order.setQuantity(remaining);
 					orderBookDao.updateOrder(order);
 				}
 				
 			}else if( receivedOrder.isSell()){
 				
 				// Sell order
 				order = orderBookDao.getOrderById( match.getBuyOrderId());
 				if( match.getBuyMatchType().equals(OrderMatch.TYPE_FULL) ){
 					orderBookDao.deleteOrder(order);
 				}else if( match.getBuyMatchType().equals(OrderMatch.TYPE_PARTIAL) ){
 					// update quantity in order book
 					int remaining = order.getQuantity() - match.getMatchedQuantity();
 					order.setQuantity(remaining);
 					orderBookDao.updateOrder(order);
 				}
 			}
 		}
 	}
 	
 	/***
 	 * store the order matches
 	 * @param matches
 	 */
 	public List<OrderFill> createOrderFills( List<OrderMatch> matches){
 		
 		List<OrderFill> fills = new ArrayList<OrderFill>();
 		
 		for( OrderMatch match : matches ){
 			
 			long orderMatchId = orderMatchDao.generateOrderMatchId();
 			match.setId(orderMatchId);
 			orderMatchDao.addOrderMatch(match);
 			
 			// TODO: create order fills
 			// each MATCH results in two order fills, one for BUY and for SELL
 			OrderFill buyFill = new OrderFill();
 			
 			buyFill.setId(match.getBuyFillId());
 			buyFill.setOrderId(match.getBuyOrderId());
 			buyFill.setMatchId(match.getId());
 			buyFill.setSymbol(match.getSymbol());
 			buyFill.setMatchPrice(match.getMatchPrice());
 			buyFill.setMatchedQuantity(match.getMatchedQuantity());
 			buyFill.setMatchType(match.getBuyMatchType());
 			buyFill.setOrderType(Order.TYPE_BUY);
 			// TODO : match time to be retrieved from table
 			buyFill.setMatchTime(match.getMatchTime());
 			
 			OrderFill sellFill = new OrderFill();
 			
 			sellFill.setId( match.getSellFillId());
 			sellFill.setOrderId(match.getSellOrderId());
 			sellFill.setMatchId(match.getId());
 			sellFill.setSymbol(match.getSymbol());
 			sellFill.setMatchPrice(match.getMatchPrice());
 			sellFill.setMatchedQuantity(match.getMatchedQuantity());
 			sellFill.setMatchType(match.getSellMatchType());
 			sellFill.setMatchTime(match.getMatchTime());
 			sellFill.setOrderType(Order.TYPE_SELL);
 			
 			fills.add(buyFill);
 			fills.add(sellFill);
 		}
 		
 		return fills;
 	}
 	
 	@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public void addMatchedOrders( List<OrderMatch> matches ){
 		
 		for( OrderMatch match : matches ){
 			long id = orderMatchDao.generateOrderMatchId();
 			long buyFillId = orderMatchDao.generateOrderFillId();
 			long sellFillId = orderMatchDao.generateOrderFillId();
 			match.setId(id);
 			match.setBuyFillId(buyFillId);
 			match.setSellFillId(sellFillId);
 			orderMatchDao.addOrderMatch(match);
 		}
 		
 	}
 	
 	public List<OrderMatch> getMatchedOrders( ReceivedOrder order ){
 		
 		List<OrderMatch> matchedOrders=null;
 		if( order.isBuy()){
 			matchedOrders = orderMatchDao.getOrderMatchesForBuyOrder(order.getId());
 		}else if( order.isSell() ){
 			matchedOrders = orderMatchDao.getOrderMatchesForSellOrder(order.getId());
 		}
 		
 		return matchedOrders;
 	}
 
 	public void matchOrder(Order order) {
 	}
 
 	public void sendOrderFills(List<OrderFill> fills) throws OrderCannotBeFilledException, OrderFillQuantityMismatchException {
 			orderSvc.fillOrders(fills);
 	}
 
 	public void sendOrderMatches(List<OrderMatch> matches) throws OrderCannotBeFilledException, 
 										NotEnoughCashException, NotValidAccountException, NotEnoughPositionsException {
 		orderSvc.executeMatches(matches);
 	}
 
 	public MarketDepth getMarketDepth(String symbol) {
 		
 		int level =5;
 		OrderBook book = getOrderBook(symbol);
 		
 		// calculate Market depth
 		MarketDepth depth = new MarketDepth();
 		depth.setSymbol(symbol);
 		depth.setLevels(level);
 		
 		// calculate "buy" depths for 5 prices
 		depth.setBuys( book.getBuyPriceDepths(level));
 		depth.setSells( book.getSellPriceDepths(level));
 		
 		return depth;
 	}
 }