/*
    *  AccountManagerService
    *
    *  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.account.service;
  
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import net.sf.emarket.account.domain.Account;
  import net.sf.emarket.account.domain.AcctPosition;
  import net.sf.emarket.account.domain.AcctPositionSummary;
  import net.sf.emarket.account.domain.AcctPositionTransfer;
  import net.sf.emarket.account.domain.AcctValue;
  import net.sf.emarket.account.domain.CashBalance;
  import net.sf.emarket.account.domain.CashTransfer;
  import net.sf.emarket.account.repository.IAccountDao;
  import net.sf.emarket.account.repository.IAccountPositionDao;
  import net.sf.emarket.account.repository.IAcctPositionTransferDao;
  import net.sf.emarket.account.repository.ICashBalanceDao;
  import net.sf.emarket.account.repository.ICashTransferDao;
  import net.sf.emarket.quote.domain.Quote;
  import net.sf.emarket.quote.service.IQuoteManagerService;
  import net.sf.emarket.quote.service.SymbolsCannotBeEmptyException;
  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.dao.EmptyResultDataAccessException;
  import org.springframework.transaction.annotation.Propagation;
  import org.springframework.transaction.annotation.Transactional;
  
  // Due to a bug in spring, we need to define a bean in applicationContext.xml for AccountManagerService
  //@Service
  public  class AccountManagerServiceImpl implements IAccountManagerService {
  	
  	private static final long serialVersionUID = -5752914821716454464L;
  	//private static Logger logger = Logger.getLogger(AccountManagerServiceImpl.class );
  	
  	private IAccountDao accountDao;
  	private IAccountPositionDao accountPositionDao;
  	private IAcctPositionTransferDao acctPositionTransferDao;
  	private ICashBalanceDao cashBalanceDao;
  	private ICashTransferDao cashTransferDao;
  
      private IQuoteManagerService quoteMgr;
      private IUserManagerService userMgr;
  	
  	@Autowired
  	public void setAccountDao( IAccountDao dao){
  		accountDao = dao;
  	}
  	
  	@Autowired
  	public void setAccountPositionDao( IAccountPositionDao dao){
  		accountPositionDao = dao;
  	}	
  	
  	@Autowired
  	public void setAcctPositionTransferDao( IAcctPositionTransferDao dao){
  		acctPositionTransferDao = dao;
  	}
  	
  	@Autowired
  	public void setCashBalanceDao( ICashBalanceDao dao){
  		cashBalanceDao = dao;
  	}
  	
  	@Autowired
  	public void setCashTransferDao( ICashTransferDao dao){
  		cashTransferDao = dao;
  	}
  
      @Autowired
     public void setQuoteManager( IQuoteManagerService mgr ){
         quoteMgr = mgr;
     }
     
     @Autowired
     public void setUserManager( IUserManagerService mgr ){
     	userMgr = mgr;
     }
 
 	public void addAccount(Account account) {
 		
 		long acctId = accountDao.generateAccountId();
 		account.setAcctId( Long.toString(acctId) );
 		account.setStatus(Account.STATUS_ACTIVE);
 		
 		accountDao.addAccount(account);
 	}
 
 	public int deleteAccountById(String acctId) {
 		return accountDao.deleteAccountById(acctId);
 	}
 
 	public Account getAccountById(String acctId) {
 		return accountDao.getAccountById(acctId);
 	}
 
 	public List<Account> getAccountsForUser(User user) {
 		return accountDao.getAccountsForUser(user)	;
 	}
 	
 	public List<Account> getAccountsOfType( String acctType ){
 		return accountDao.getAccountsOfType(acctType);
 	}
 
 	public int updateAccount(Account account) {
 		return accountDao.updateAccount(account);
 	}
 
 	public CashBalance getCashBalance(Account account) {
 		
 		CashBalance balance = new CashBalance();
 		
 		try{
 			balance = cashBalanceDao.getCashBalance(account);
 		}catch( EmptyResultDataAccessException ere){
 			balance.setAmount(0l);
 		}
 		
 		return balance;
 	}
 
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
     public void tranferCash(CashTransfer transfer) throws NotEnoughCashException, NotValidAccountException {
 	
 		// first check whether the sender has enough money to send
 		CashBalance senderBalance = cashBalanceDao.getCashBalance(transfer.getSenderAcctId());
 		if( senderBalance.getAmount() < transfer.getAmount() ){
 			String message = "Account "+ transfer.getSenderAcctId() + " does not have cash to transfer";
 			throw new NotEnoughCashException( message );
 		}
 		
 		// check whether receiver account exists and active
 		Account receiverAccount = accountDao.getAccountById(transfer.getReceiverAcctId());
 		
 		if( receiverAccount != null && 
 				( receiverAccount.getStatus().equals( Account.STATUS_INACTIVE) ||
 				  receiverAccount.getStatus().equals( Account.STATUS_DISABLED) )
 			){
 			
 			String message = "Receiver account "+ transfer.getReceiverAcctId() + " is not a valid account";
 			throw new NotValidAccountException(message);
 		}
 		
 		// subtract the transfer amount from sender balance
 		float remaining = senderBalance.getAmount() - transfer.getAmount();
 		senderBalance.setAmount(remaining);
 		senderBalance.setAcctId(transfer.getSenderAcctId());
 		cashBalanceDao.updateCashBalance(senderBalance);
 	
 		//get receiver balance
 		CashBalance receiverBalance = new CashBalance();
 		boolean insertFlag = false;
 		
 		try{
 			receiverBalance = cashBalanceDao.getCashBalance(transfer.getReceiverAcctId());
 		}catch(EmptyResultDataAccessException ere){
 			insertFlag = true;
 			receiverBalance.setAmount(0f);
 		}
 		
 		float addition = receiverBalance.getAmount() + transfer.getAmount();
 		receiverBalance.setAmount(addition);
 		receiverBalance.setAcctId(transfer.getReceiverAcctId());
 		
 		// update receiver balance
 		if( insertFlag ){
 			cashBalanceDao.addCashBalance(receiverBalance);
 		}else{
 			cashBalanceDao.updateCashBalance(receiverBalance);
 		}
 		
 		// generate transfer Id
 		long transferId = cashTransferDao.generateTransferId();
 		transfer.setTransferId(transferId);
 		
 		Date date = new Date();
 		Timestamp createdTime = new Timestamp( date.getTime());	
 		transfer.setCreatedTime(createdTime);
 		
 		// record CashTransfer
 		transfer.setTransferStatus(CashTransfer.STATUS_COMPLETED);
 		cashTransferDao.addCashTransfer(transfer);
     }
     
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
     public void transferPosition( AcctPositionTransfer transfer ) throws NotEnoughPositionsException, NotValidAccountException{
     	
     	// first check the sender has enough positions to send
     	List<AcctPosition> positions = accountPositionDao.getAccountPositions(transfer.getSenderAcctId(), transfer.getSymbol());
     	int totalQuantity = 0;
     	
     	for( AcctPosition position : positions ){
     		totalQuantity += position.getQuantity();
     	}
     	
     	if( totalQuantity < transfer.getQuantity() ){
     		// the sender cannot transfer positions, that he doesn't have.
     		String message = "Account: "+ transfer.getSenderAcctId() +" does not have "+ 
     											transfer.getQuantity() + " positions of "+ transfer.getSymbol();
     		
     		throw new NotEnoughPositionsException(message );
     	}
     	
     	// check whether receiver account exists and valid
 		Account receiverAccount = accountDao.getAccountById(transfer.getReceiverAcctId());
 		
 		if( receiverAccount != null && 
 				( receiverAccount.getStatus().equals( Account.STATUS_INACTIVE) ||
 				  receiverAccount.getStatus().equals( Account.STATUS_DISABLED) )
 			){		
 			String message = "Receiver account "+ transfer.getReceiverAcctId() + " is not a valid account";
 			throw new NotValidAccountException(message);
 		}
 		
 		
 		// delete or subtract  the positions from sender		
 		int remaining = transfer.getQuantity();
 		for( AcctPosition senderPosition : positions){
 			
 			if( senderPosition.getQuantity() <= remaining ){
 				remaining -= senderPosition.getQuantity();
 				accountPositionDao.deleteAccountPosition(senderPosition);
 			}else if( senderPosition.getQuantity() > remaining ){
 				long updateQuantity = senderPosition.getQuantity() - remaining;
 				remaining =0;
 				senderPosition.setQuantity(updateQuantity);
 				accountPositionDao.updateAccountPosition(senderPosition);
 			}
 
 			if( remaining == 0){
 				break;
 			}else if( remaining < 0){
 				// error condition. should never reach here.
 				// we never know
 			}
 		}
 
 		// add positions to the receiver
 		AcctPosition receiverPosition = new AcctPosition();
 		receiverPosition.setAcctId(transfer.getReceiverAcctId());
 		receiverPosition.setQuantity(transfer.getQuantity());
 		receiverPosition.setSymbol(transfer.getSymbol());
         receiverPosition.setPurchasePrice( transfer.getPrice());
 
         // calculate totalPrice
         float totalPrice = receiverPosition.getPurchasePrice() * receiverPosition.getQuantity();
         // TODO : total price should include commissions, fees etc
         receiverPosition.setTotalPrice(totalPrice);
 		
 		long posId = accountPositionDao.generateAcctPositionId();
 		receiverPosition.setId(posId);
 		
 		accountPositionDao.addAccountPosition(receiverPosition);
 
 
 		// generate transfer Id
 		long transferId = acctPositionTransferDao.generateTransferId();
 		transfer.setTransferId(transferId);
 		
 		Date date = new Date();
 		Timestamp createdTime = new Timestamp( date.getTime());	
 		transfer.setCreatedTime(createdTime);
 		
 		// record CashTransfer
 		transfer.setTransferStatus(CashTransfer.STATUS_COMPLETED);
 		acctPositionTransferDao.addAcctPositionTransfer( transfer);		
 		
     }
 
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public AcctPosition addAccountPosition(AcctPosition position) {
 		long acctPosId = accountPositionDao.generateAcctPositionId();
 		position.setId(acctPosId);
 		return accountPositionDao.addAccountPosition(position);
 	}
 
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public void deleteAccountPosition(AcctPosition position) {
 		accountPositionDao.deleteAccountPosition(position);
 	}
 
 	public AcctPosition getAccountPosition(long acctPositionId) {
 		return accountPositionDao.getAccountPosition(acctPositionId);
 	}
 
 	public List<AcctPosition> getAccountPositions(String acctId) {
 		return accountPositionDao.getAccountPositions(acctId);
 	}
 
 	public List<AcctPosition> getAccountPositions(String acctId, String symbol) {
 		return accountPositionDao.getAccountPositions(acctId, symbol);
 	}
 
     public float getTotalValueOfPositions(String acctId) {
 
         List<AcctPosition> positions =  getAccountPositions( acctId );
 
         List<String> symbols = new ArrayList<String>();
         for( AcctPosition pos : positions){
             symbols.add( pos.getSymbol());
         }
 
         float total = 0f;
         List<Quote> quotes;
         
 		try {
 			
 			quotes = quoteMgr.getQuotes(symbols);
 	        // calculate portfolio value based on last price
 		     
 	        for( AcctPosition pos : positions ){
 	            String symbol = pos.getSymbol();
 	            Quote quote=null;
 	            for( Quote q : quotes ){
 	                if( q.getSymbol().equals(symbol)){
 	                    quote = q;
 	                    break;
 	                }
 	            }
 
 	            if( quote != null ){
 	                float value = pos.getQuantity() * quote.getLastPrice();
 	                total += value;
 	            }
 	        }
 	        
 		} catch (SymbolsCannotBeEmptyException e) {
 			e.printStackTrace();
 		} 
 
 
 
         return total;
     }
 
     @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
 	public AcctPosition updateAccountPosition(AcctPosition position) {
 		return accountPositionDao.updateAccountPosition(position);
 	}
 
 	public List<AcctPositionSummary> getAccountPositionsSummary(String acctId) {
 
         List<AcctPosition> positions =  getAccountPositions( acctId );
 
         List<String> symbols = new ArrayList<String>();
         for( AcctPosition pos : positions){
             symbols.add( pos.getSymbol());
         }
 
         float total = 0f;
         List<Quote> quotes;
         
         List<AcctPositionSummary> acctSummaries = new ArrayList<AcctPositionSummary>();
         
 		try {
 			
 			quotes = quoteMgr.getQuotes(symbols);
 	        // calculate portfolio value based on last price
 			
 			for( Quote q : quotes ){
 				
 					String symbol = q.getSymbol();
 					int totalShares = 0;
 					float totalPrice = 0;
 					float totalCurrentPrice =0;
 					
 					// calculate the average price for each symbol
 					for( AcctPosition pos : positions ){
 						if( !q.getSymbol().equals(pos.getSymbol())){
 							continue;
 						}
 						
 						totalShares += pos.getQuantity();
 						totalPrice += pos.getQuantity() * pos.getPurchasePrice();
 						totalCurrentPrice += pos.getQuantity() * q.getLastPrice();
 					}
 					
 					AcctPositionSummary acctPos = new AcctPositionSummary();
 					
 					acctPos.setAcctId(acctId);
 					acctPos.setSymbol(symbol);
 					acctPos.setQuantity(totalShares);
 					float avgPurchasePrice = totalPrice / totalShares;
 					acctPos.setAveragePurchasePrice(avgPurchasePrice);
 					acctPos.setTotalPurchasePrice(totalPrice);
 					
 					acctPos.setCurrentPrice(q.getLastPrice());
 					acctPos.setCurrentValue(totalCurrentPrice);
 					
 					acctSummaries.add(acctPos);
 					
 			}
 		     
 	        
 		} catch (SymbolsCannotBeEmptyException e) {
 			e.printStackTrace();
 		} 
 
 		return acctSummaries;
 	}
 
 	public List<AcctValue> getTopAccounts(int count) {
 
 		// get the list of all accounts that are not system accounts
 		List<Account> accounts = getAccountsOfType( Account.TYPE_CASH);
 		
 		// get the total value of positions in batches
 		List<AcctValue> acctValues = new ArrayList<AcctValue>();
 		for( Account acct : accounts ){
 			
 			float totalValue = getTotalValueOfPositions( acct.getAcctId());
 			
 			AcctValue v  = new AcctValue();
 			v.setAccount(acct);
 			v.setValue( new Float(totalValue) );
 			acctValues.add(v);
 		}
 		
 		
 		for( AcctValue value : acctValues ){
 			CashBalance balance = getCashBalance( value.getAccount() );
 			float total = value.getValue() + balance.getAmount();
 			value.setValue(total);
 		}
 		
 		// we need to sort in descending order
 		Collections.sort(acctValues, new Comparator<AcctValue>(){
 			public int compare(AcctValue o1, AcctValue o2) {
 				int diff =  (int) (o1.getValue() - o2.getValue());
 				return (-diff);
 			}
 		});
 		
 		// did we get 'count' number of records?
 		int sortcount =0;
 		if( count <= acctValues.size()){
 			sortcount = count;
 		}else{
 			sortcount = acctValues.size();
 		}
 		
 		//get Users for Account, for the first 'count' accounts that have highest value
 		List<AcctValue> sortedList = new ArrayList<AcctValue>(sortcount);
 		for( int i=0; i<sortcount; i++ ){
 			AcctValue acctValue = acctValues.get(i);
 			try {
 				User user = userMgr.getUserById( acctValue.getAccount().getId() );
 				acctValue.setUser(user);
 				sortedList.add(acctValue);
 			} catch (UserNotFoundException e) {
 				e.printStackTrace();			
 			}
 		}
 				
 		return sortedList;
 	}
 	
 	private Map<String,Float> sortMapByValue(Map<String,Float> map){
 		
 		  List<CustomEntry> list = new ArrayList<CustomEntry>();
 		  Set<Map.Entry<String,Float>> entrySet = map.entrySet();
 		  Iterator<Map.Entry<String,Float>>  iterator = entrySet.iterator();
 		  
 		  while (iterator.hasNext()) {
 			Map.Entry<String,Float> entry = iterator.next();
 		    CustomEntry customEntry = new CustomEntry(entry);
 		    list.add(customEntry);
 		  }
 		  
 		  Collections.sort(list);
 		  
 		  // now construct the map again
 		  Map<String,Float> sortedMap = new HashMap<String,Float>();
 		  for(CustomEntry entry : list ){
 			  Map.Entry<String,Float> mEntry = entry.getEntry();
 			  sortedMap.put(mEntry.getKey(), mEntry.getValue());
 		  }
 
 		return sortedMap;
 	}
 	
 	public class CustomEntry implements Comparable{
 		  private Map.Entry<String,Float> entry;
 
 		  public CustomEntry(Map.Entry<String,Float> entry) {
 		   this.entry = entry;
 		  }
 
 		  public Map.Entry<String,Float> getEntry() {
 		    return this.entry;
 		  }
 
 		  public int compareTo(CustomEntry anotherEntry) {
 		    Float thisFloatVal = this.getEntry().getValue();
 		    float thisVal = thisFloatVal.floatValue();
 		    Float anotherFloatVal = anotherEntry.getEntry().getValue();
 		    float anotherVal = anotherFloatVal.floatValue();
 		    return (thisVal > anotherVal ? 1 : (thisVal==anotherVal ? 0 : -1));
 		  }
 
 		  public int compareTo(Object o) {
 		    return compareTo((CustomEntry)o);
 		  }
 
 		}
 }