/*
    *  
    *  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.order.service;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Logger;
  
  import net.sf.emarket.account.domain.Account;
  import net.sf.emarket.account.domain.AcctPosition;
  import net.sf.emarket.account.domain.AcctPositionTransfer;
  import net.sf.emarket.account.domain.CashBalance;
  import net.sf.emarket.account.domain.CashTransfer;
  import net.sf.emarket.account.service.AccountNotActiveException;
  import net.sf.emarket.account.service.IAccountManagerService;
  import net.sf.emarket.account.service.InSufficientCashBalanceException;
  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.domain.TimeComparator;
  import net.sf.emarket.order.repository.IOrderDao;
  import net.sf.emarket.quote.domain.Instrument;
  import net.sf.emarket.quote.domain.Quote;
  import net.sf.emarket.quote.domain.Instrument;
  import net.sf.emarket.quote.service.IQuoteManagerService;
  import net.sf.emarket.system.service.IMailSenderService;
  import net.sf.emarket.trade.domain.OrderFill;
  import net.sf.emarket.trade.domain.OrderMatch;
  import net.sf.emarket.trade.service.IOrderExecutorService;
  import net.sf.emarket.user.domain.User;
  import net.sf.emarket.user.service.IUserManagerService;
  import net.sf.emarket.user.service.UserNotFoundException;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.mail.SimpleMailMessage;
  import org.springframework.transaction.annotation.Propagation;
  import org.springframework.transaction.annotation.Transactional;
  
  
  public class OrderManagerServiceImpl implements IOrderManagerService  {
  	
  	private static final long serialVersionUID = 6143050250286605772L;
  
  	private static Logger logger = Logger.getLogger( OrderManagerServiceImpl.class.getName() );
  	
  	private IOrderDao orderDao = null;
  	private IUserManagerService userMgr =null;
  	private IAccountManagerService acctMgr = null;
  	private IQuoteManagerService quoteMgr = null;
  	private IOrderExecutorService orderExecutor = null;
      private IMailSenderService mailSender;
      private SimpleMailMessage templateMessage;
  
  
  	@Autowired
  	public void setOrderDao( IOrderDao dao){
  		orderDao = dao;
  	}
  	
  	@Autowired
  	public void setUserManager( IUserManagerService mgr){
  		userMgr = mgr;
  	}
  	
  	@Autowired
  	public void setAccountManager( IAccountManagerService acctMgrSvc ){
  		acctMgr = acctMgrSvc;
  	}
  	
  	@Autowired
  	public void setQuoteManager( IQuoteManagerService quoteMgrSvr ){
  		quoteMgr = quoteMgrSvr;
  	}
  	
  	@Autowired
  	public void setOrderExecutor( IOrderExecutorService executor){
  		orderExecutor = executor;
 	}
 	
     @Autowired
     public void setMailSender(IMailSenderService mailSender) {
         this.mailSender = mailSender;
     }
 
     @Autowired
     public void setTemplateMessage(SimpleMailMessage templateMessage) {
         this.templateMessage = templateMessage;
     }
 		
 
 	@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public Order placeOrder(Order order) throws AccountNotActiveException, InSufficientCashBalanceException, NotEnoughPositionsException, InstrumentCannotTradeException, WrongLimitPriceExeption {
 	
 		// verify the order, if it is not done before
 		Order verifiedOrder = null;
 		if( order.getId() == null || order.getId().trim().equals("") ){
 			verifiedOrder = verifyOrder(order);
 		}else{
 			// TODO: need better logic to figure out whether the order is verified and it is still valid
 			verifiedOrder =order;
 		}
 		
 		//Sometimes, the verification was done long ago.
 		// TODO: we need to check whether it is still valid
 		
 	
 		// change the status 
 		verifiedOrder.setStatus(Order.STATUS_OPEN);
 		
 		// place the order, with order management system
 		orderDao.updateOrder(verifiedOrder);
 		
 		// send the order to the trading engine
 		orderExecutor.execute(verifiedOrder);
 		
 		return verifiedOrder;
 	}
 	
 	@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public Order verifyOrder( Order order )
             throws AccountNotActiveException, InSufficientCashBalanceException, NotEnoughPositionsException, InstrumentCannotTradeException, WrongLimitPriceExeption {
 		
 		// TODO: determine the type of "trade" by looking at the order
 		
 		
 		// get the account status
 		Account account = acctMgr.getAccountById(order.getAcctId());
 		
 		String acctStatus = account.getStatus();
 		if( !acctStatus.equals( Account.STATUS_ACTIVE) ){
 			throw new AccountNotActiveException( "Account  "+  account.getAcctId() + " not active");
 		}
 		
 		// TODO: check whether the account is enabled for this type of trading
 		
 		// get the quote
 		Quote quote = quoteMgr.getQuote(order.getSymbol());
 
 
         //Check whether the instrument is allowed to trade
         if( !quote.getInstrument().getStatus().equals( Instrument.STATUS_ACTIVE )){
              throw new InstrumentCannotTradeException("Symbol "+ quote.getSymbol() + " is not allowed trade" );
         }
 		
 		// Store the quote Id in order
 		order.setQuoteId(quote.getId());
 
 /*        // if it is a limit order, the limit price should be within a range
         if( order.isLimitOrder() ){
             if( order.isBuy() ){
                // limit price cannot be higher than the best bid price
                 if( order.getLimitPrice() > quote.getAskPrice() ){
                         throw new WrongLimitPriceExeption("Buy limit price " + order.getLimitPrice() + " is greater than ask price " + quote.getAskPrice());
                 }
 
             }else if( order.isSell() ){
                 // limit price cannot be lower than the best ask price
                 if( order.getLimitPrice() < quote.getBidPrice() ){
                         throw new WrongLimitPriceExeption("Sell limit price " + order.getLimitPrice() + " is lesser than bid price "+ quote.getBidPrice() );
                 }
             }
         }*/
 		
 		// calculate the cost 
 		float cost = calculateCost(order, quote);
 		
 		// determine commission
 		float commission = calculateCommision(account, order);
 		order.setCommission(commission);
 		
 		// compute total
 		// total = cost + commission
 		float totalCost = cost + commission;
 		order.setTotalCost(totalCost);
 		
 		
 		// check whether account has enough money to BUY 
 		// or
 		// whether the account has enough shares to SELL
 		if( order.getOrderType().equals( Order.TYPE_BUY) ){
 			CashBalance balance = acctMgr.getCashBalance(account);
 			if( balance.getAmount() < order.getTotalCost() ){
 				throw new InSufficientCashBalanceException("Account "+ account.getAcctId()
                         + " doesn't have enough cash balance.");
 			}
 
             float totalCashNeeded = 0f;
             // check whether there are any other "BUY" orders that need the cash
             List<Order> openOrders = orderDao.getOrdersForAcctIdWithStatusAndSymbol( account.getAcctId(),
                                                                                                                                                     Order.STATUS_OPEN,
                                                                                                                                                     order.getSymbol());
 
             for( Order o : openOrders ){
                 totalCashNeeded += ( o.getQuantity() * o.getLimitPrice() );
             }
 
             // get all partialy filled orders for this account and symbol
             List<Order> partiallyFilledOrders =  orderDao.getOrdersForAcctIdWithStatusAndSymbol( account.getAcctId(),
                                                                                                                                                     Order.STATUS_PARTIALLY_FILLED ,
                                                                                                                                                     order.getSymbol());
 
             for( Order o : partiallyFilledOrders ){
                 totalCashNeeded += ((o.getQuantity() - o.getFilledQuantity())) * o.getLimitPrice();
             }
 
             if( balance.getAmount() < ( totalCashNeeded + order.getTotalCost() ) ){
                     throw new InSufficientCashBalanceException("Account "+ account.getAcctId()
                             + " doesn't have enough cash balance, because there are other BUY orders.");
             }
 
 
 		}else if(order.getOrderType().equals( Order.TYPE_SELL)){
 			
 			List<AcctPosition> positions = acctMgr.getAccountPositions(account.getAcctId(), order.getSymbol());
 			
 			//calculate the total number of positions owned by the user
 			long total = 0;
 			for( AcctPosition pos : positions ){
 				total = total + pos.getQuantity();
 			}
 			
 			if( total < order.getQuantity() ){
 				throw new NotEnoughPositionsException("Account "+ account.getAcctId()
                         + " doesn't have enough positions to sell");
 			}
 
             int totalPositionsOpen = 0;
 
             //  make sure the positions are not part of a sell order already
             // get all open orders for this account and symbol
             List<Order> openOrders = orderDao.getOrdersForAcctIdWithStatusAndSymbol( account.getAcctId(),
                                                                                                                                                     Order.STATUS_OPEN ,
                                                                                                                                                     order.getSymbol());
 
             for( Order o : openOrders ){
                     totalPositionsOpen += o.getQuantity();
             }
 
             // get all partialy filled orders for this account and symbol
             List<Order> partiallyFilledOrders =  orderDao.getOrdersForAcctIdWithStatusAndSymbol( account.getAcctId(),
                                                                                                                                                     Order.STATUS_PARTIALLY_FILLED ,
                                                                                                                                                     order.getSymbol());
 
             for( Order o : partiallyFilledOrders ){
                 totalPositionsOpen += (o.getQuantity() - o.getFilledQuantity());
             }
 
             if( total < ( order.getQuantity() + totalPositionsOpen) ){
                 throw new NotEnoughPositionsException("Account "+ account.getAcctId() + " doesn't have enough positions to sell, since "
                                     + totalPositionsOpen + " shares are already on sale");  
             }
 
         }
 		
 		
 		// set status of the order to "VERIFIED"
 		order.setStatus(Order.STATUS_VERIFIED);
 	
 		// generate order Id
 		long orderId = orderDao.generateOrderId();
 		order.setId( Long.toString(orderId) );
 		
 		// add to EM_ORDER table
 		orderDao.addOrder(order);
 		
 		// retreive the order, with order created time
 		Order verifiedOrder = orderDao.getOrderById(order.getId());
 		
 		// TODO: generate order_history_id
 		
 		// TODO: record EM_ORDER_HISTORY table
 		
 		return verifiedOrder;
 	}
 	
 	public float calculateCommision( Account account, Order order ){
 		
 		float commission = 0f;
 		
 		return commission;
 	}
 
 	public List<Order> getOpenOrdersForAcctId(String acctId) {
         
 		List<Order> openorders =orderDao.getOrdersForAcctIdWithStatus( acctId , Order.STATUS_OPEN);
         List<Order> partiallFilledOrders = orderDao.getOrdersForAcctIdWithStatus(acctId,  Order.STATUS_PARTIALLY_FILLED);
 
         openorders.addAll(partiallFilledOrders);
         
         // FIXME : only for pridict.com
         Comparator reverseTimeComparator = Collections.reverseOrder( new TimeComparator());
         Collections.sort(openorders, reverseTimeComparator);
         
 		return openorders;
 	}
 
     public List<Order> getExecutedOrdersForAcctId(String acctId) {
 
         List<Order> filledOrders  = orderDao.getOrdersForAcctIdWithStatus(acctId, Order.STATUS_FILLED);
         List<Order> partiallyFilledOrders  = orderDao.getOrdersForAcctIdWithStatus(acctId, Order.STATUS_PARTIALLY_FILLED);
         filledOrders.addAll(partiallyFilledOrders);
         
         // FIXME : only for pridict,com
         Comparator reverseTimeComparator = Collections.reverseOrder( new TimeComparator());
         Collections.sort( filledOrders, reverseTimeComparator);
 
         return filledOrders;
     }
 
     private float calculateCost( Order order, Quote quote){
 		
 		float cost = 0f;
 
         if( order.getPriceType().equals( Order.PRICE_TYPE_LIMIT) ){
 			    cost = order.getQuantity() * order.getLimitPrice();
         }else if( order.getPriceType().equals( Order.PRICE_TYPE_MARKET)  ){
                 if( order.getOrderType().equals( Order.TYPE_BUY )){
                     // calculate based on lowest ask price
                    cost = order.getQuantity() * quote.getAskPrice();
                 }
                 if( order.getOrderType().equals(Order.TYPE_SELL)){
                     // calculate based on highest bid price
                     cost = order.getQuantity() * quote.getBidPrice();
                 }           
         }
 		
 		return cost;
 	}
 
 	/***
 	 * <code>fillOrders</code> .
 	 * <OL>
 			<li>determine how many cash transfers are needed</li>
 			<li>collect money from BUY accounts</li>
 			<li>collect positions from SELL accounts</li>
 			<li>Transfer cash from BUY account to SELL account</li>
 			<li>Transfer position from SELL account from BUY account</li>
 		</OL>
 
 	 */
 	@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public void fillOrders(List<OrderFill> fills) throws OrderCannotBeFilledException, OrderFillQuantityMismatchException {
 		
 		// TODO: order fills must be recorded by OMS, when it receives them
 		// now updating the order directly for the sake of time... not correct
 		
 		// retrieve the orders from OMS
 		Map<String, Order> orders = new HashMap<String,Order>();
 		
 		for( OrderFill fill : fills ){
 			Order order = orderDao.getOrderById(fill.getOrderId());
 			
 			// to receive a fill, order must be "open" or "partially filled"
 			if( !order.getStatus().equalsIgnoreCase(Order.STATUS_OPEN) || 
 					!order.getStatus().equalsIgnoreCase(Order.STATUS_PARTIALLY_FILLED) ){
 				throw new OrderCannotBeFilledException("Order Id : "+ fill.getOrderId() + " cannot be filled");
 			}
 			
 			if( fill.getMatchedQuantity() > order.getQuantity() ){
 				// this is an error condition, something is wrong, it could be bug or system inconsistency
 				throw new OrderFillQuantityMismatchException("Order fill quantity exceeds the order quantity for Order Id: "
 																									+ fill.getOrderId() + ", fillId: "+ fill.getId() );
 			}
 			
 			orders.put(fill.getOrderId(), order);
 		}
 		
 
 
 		
 		// STEP :1
 		// determine how many cash transfers are needed.
 		// all order fill method invocation, will have one side will be just one.
 		// i.e., one BUY fill matching many SELLs or
 		//        one SELL fill with many matching BUY fills
 		// if not there is an error
 		int buys = 0;
 		int sells =0;
 		for( OrderFill fill : fills){
 			if( fill.getOrderType().equals(Order.TYPE_BUY) ){
 				buys += 1;
 			}
 			if( fill.getOrderType().equals(Order.TYPE_SELL) ){
 				sells +=1;
 			}
 		}
 		
 		// either "buys" or "sells" must be 1, or error
 		if( buys == 0 && sells == 0){
 			// ERROR
 		}else if( buys > 1 && sells > 1){
 			// ERROR
 		}
 		
 		boolean moreSells = false;
 		if( buys == 1 && sells > 1 ){
 			moreSells = true;
 		}else if( buys > 1 && sells == 1 ){
 			moreSells = false;
 		}
 		
 		List<CashTransfer> cashTransfers = new ArrayList<CashTransfer>();
 		List<AcctPositionTransfer> acctPosTransfers = new ArrayList<AcctPositionTransfer>();
 		
 		if( moreSells ){
 			for( OrderFill fill : fills ){
 				if( fill.getOrderType().equals(Order.TYPE_SELL ) ){
 					
 						Order order = orders.get(fill.getOrderId());
 						CashTransfer cashTransfer = new CashTransfer();
 						cashTransfer.setReceiverAcctId(order.getAcctId());
 						cashTransfer.setAmount(cashTransfer.getAmount());						
 						cashTransfers.add(cashTransfer);
 						
 						AcctPositionTransfer posTransfer = new AcctPositionTransfer();
 						posTransfer.setSenderAcctId(order.getAcctId());
 						posTransfer.setQuantity(fill.getMatchedQuantity());
 						acctPosTransfers.add(posTransfer);
 				}
 			}
 			
 		}else if( !moreSells ){
 			
 			for( OrderFill fill : fills ){
 				if( fill.getOrderType().equals(Order.TYPE_BUY ) ){
 			
 						Order order = orders.get(fill.getOrderId());
 						CashTransfer cashTransfer = new CashTransfer();
 						cashTransfer.setSenderAcctId(order.getAcctId());
 						cashTransfer.setAmount(cashTransfer.getAmount());
 						cashTransfers.add(cashTransfer);
 						
 						AcctPositionTransfer posTransfer = new AcctPositionTransfer();
 						posTransfer.setReceiverAcctId( order.getAcctId() );
 						posTransfer.setQuantity(fill.getMatchedQuantity());
 						acctPosTransfers.add( posTransfer);
 				}
 			}			
 		}
 		
 		//
 	}
 
 
 	
 	/***
 	 * 
 	 * <code>executeMatches()</code> transfers the positions and cash after order execution.
 	 * This method is a short term hack. 
 	 * This will be replaced by fillOrder() and a corresponding clearing system.
 	 * @param matches
 	 * @throws OrderCannotBeFilledException 
 	 * @throws NotValidAccountException 
 	 * @throws NotEnoughCashException 
 	 * @throws NotEnoughPositionsException 
 	 */
 	public void executeMatches( List<OrderMatch> matches) 
         throws OrderCannotBeFilledException, NotEnoughCashException, NotValidAccountException, NotEnoughPositionsException{
 		
 		// each match results in one cash transfer and one position transfer
 		for( OrderMatch match : matches ){
 			
 			Order buyOrder = orderDao.getOrderById( match.getBuyOrderId() );
 			Order sellOrder = orderDao.getOrderById(match.getSellOrderId());
 			
 			// to receive a fill, order must be "open" or "partially filled"
 			if( !buyOrder.getStatus().equalsIgnoreCase(Order.STATUS_OPEN) &&
 					!buyOrder.getStatus().equalsIgnoreCase(Order.STATUS_PARTIALLY_FILLED) ){
 				throw new OrderCannotBeFilledException("Order Id : "+ match.getBuyFillId() + " cannot be filled");
 			}
 			if( !sellOrder.getStatus().equalsIgnoreCase(Order.STATUS_OPEN) &&
 					!sellOrder.getStatus().equalsIgnoreCase(Order.STATUS_PARTIALLY_FILLED) ){
 				throw new OrderCannotBeFilledException("Order Id : "+ match.getSellFillId() + " cannot be filled");
 			}
 			
 			CashTransfer cashTransfer = new CashTransfer();
 			float amount = match.getMatchPrice() * match.getMatchedQuantity();
 			cashTransfer.setAmount(amount);
 			cashTransfer.setSenderAcctId(buyOrder.getAcctId());
 			cashTransfer.setReceiverAcctId(sellOrder.getAcctId());
 			// TODO :  price received should be minus commissions, fees etc
 			acctMgr.tranferCash(cashTransfer);
 			
 			AcctPositionTransfer positionTransfer = new AcctPositionTransfer();
 			positionTransfer.setSenderAcctId( sellOrder.getAcctId());
 			positionTransfer.setReceiverAcctId( buyOrder.getAcctId() );
 			positionTransfer.setQuantity(match.getMatchedQuantity());
             positionTransfer.setPrice( match.getMatchPrice());
 			positionTransfer.setSymbol(match.getSymbol());
 			
 			acctMgr.transferPosition(positionTransfer);
 
 			// at this point update the 'OPEN' orders to 'FILLED' or 'PARTIALLY_FILLED'
 			if( match.getBuyMatchType().equals(OrderMatch.TYPE_FULL)){
 				buyOrder.setStatus(Order.STATUS_FILLED);
                 buyOrder.setFilledQuantity(match.getMatchedQuantity());
 			}else if(match.getBuyMatchType().equals(OrderMatch.TYPE_PARTIAL)){
 				buyOrder.setStatus(Order.STATUS_PARTIALLY_FILLED);
                 int matchedQuantity = match.getMatchedQuantity() + buyOrder.getFilledQuantity();
                 buyOrder.setFilledQuantity(matchedQuantity);
 			}
 			
 			orderDao.updateOrder(buyOrder);
 
 			
 			if(match.getSellMatchType().equals(OrderMatch.TYPE_FULL)){
 				sellOrder.setStatus(Order.STATUS_FILLED);
                 sellOrder.setFilledQuantity(match.getMatchedQuantity());
 			}else if(match.getSellMatchType().equals(OrderMatch.TYPE_PARTIAL)){
 				sellOrder.setStatus(Order.STATUS_PARTIALLY_FILLED);
                 int matchedQuantity = match.getMatchedQuantity() + sellOrder.getFilledQuantity();
                 sellOrder.setFilledQuantity(matchedQuantity);
 			}
 			
 			orderDao.updateOrder(sellOrder);
 			
 			Account buyerAcct = acctMgr.getAccountById( buyOrder.getAcctId() );
 			Account sellerAcct = acctMgr.getAccountById(sellOrder.getAcctId());
 			try {
 
 				User buyer = userMgr.getUserById( buyerAcct.getId());
 				logger.info("sending mail to buyer");
 				sendMail( buyer.getId(), buyOrder);
 				User seller = userMgr.getUserById( sellerAcct.getId());
 				logger.info("sending mail to seller");
 				sendMail( seller.getId(), sellOrder);
 				
 			} catch (UserNotFoundException e) {
 				e.printStackTrace();
 				logger.severe("User not found exception: "  + e.getMessage());
 			}
 		}
 	}
 	
 	private void sendMail( String email, Order order){
 		
         SimpleMailMessage msg = new SimpleMailMessage(this.templateMessage);
         
         msg.setTo(email);
         msg.setSubject("Re: order no. "+ order.getId());
         
         StringBuilder sb = new StringBuilder();
         sb.append("your ");
         
         if( order.isBuy() ){
         	sb.append("buy ");
         }else if( order.isSell()){
         	sb.append("sell ");
         }
         
         sb.append(" order for "+ order.getQuantity() );
         sb.append(" shares of " + order.getSymbol());
         sb.append(" is ");
         
         if( order.getStatus().equals(Order.STATUS_FILLED) ){
         	sb.append("filled completely");
         }
         if( order.getStatus().equals(Order.STATUS_PARTIALLY_FILLED) ){
         	sb.append("filled partially");
         }        
         
         msg.setText(sb.toString());
 
         logger.info("sending message : \n"+ msg.toString());
         this.mailSender.sendMail(msg);       
 	}
 	
 /*	public static void main(String[] args){
 		
 		XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("WEB-INF/applicationContext.xml"));
 		IOrderManagerService svc = (IOrderManagerService) beanFactory.getBean("IOrderManagerService");
 		
 		SimpleMailMessage msg = (SimpleMailMessage) beanFactory.getBean("templateMessage");
 		MailSender mailSender = (MailSender) beanFactory.getBean("mailSender");
 		
         
         msg.setTo("snambi@gmail.com");
         msg.setSubject("Re: order no. "+ 100);
         
         StringBuilder sb = new StringBuilder();
         sb.append("your message ");
 
         msg.setText(sb.toString());
 
         try{
             mailSender.send(msg);
         }catch(MailException ex) {
             ex.printStackTrace();
         }		
 		
 	}*/
 
 }