package fauxExchange;

import java.util.Iterator;

class BreakRule implements Rule{
	
	//Precondition :: OrderBook is not empty
	public Trade processRule(OrderBook ob, Order o) throws TradeClosedException {
		if (!hasBuysAndSells(ob)){
			ob.setOpeningPrice(0.0); //- No trades....
		}
		//Precondition :: The book has buys and sells
		else if (!containsMarket(ob)){
			//Precondition :: we have buys and sells and NO market orders...
			if(limitsOverlap(ob)){
				ob.setOpeningPrice(maximumExecution(ob));
			}
			//Precondition :: There are no market orders and no buy and sell limits
			//overlap each other (NO TRADE)
			else{
				ob.setOpeningPrice(0.0);
			}
		}
		//Precondition :: The book contains markets
		else if(onlyMarkets(ob)){
			ob.setOpeningPrice(ob.getLastPrice());
		}else if(onlyMarketsOnOneSide(ob)){
			ob.setOpeningPrice(getBestOneSidePrice(ob));
		}else{
			ob.setOpeningPrice(maximumExecution(ob));
		}
		
		return null;
	}
	
	public boolean fitsCriteria (OrderBook ob, Order o) {
		return true;
	}
	

	//Method to check if an OrderBook has buys && sells (not necessarily matchable)
	public boolean hasBuysAndSells(OrderBook ob){
	  return(ob.getBuyOrders().hasNext() && ob.getSellOrders().hasNext());
	} //end hasBuysAndSells()
	
	
	//Precondition :: There are buys & sells in the book 
	//Does an OrderBook contain any markets (buy or sell)?
	public boolean containsMarket(OrderBook ob){
		Iterator buys = ob.getBuyOrders();
		Iterator sells = ob.getSellOrders();
		Order o1 = (Order)buys.next();
		Order o2 = (Order)sells.next();
		if (o1.isMarket() || o2.isMarket()){return true;}
		else
		  return false;
	}//end containsMarket
		
		
  //Precondition :: We are dealing with a system that has *only* limit orders
	//                The purpose here is to determine if a matching trade is possible
	public boolean limitsOverlap(OrderBook ob){
		Iterator buys = ob.getBuyOrders();
		Iterator sells = ob.getSellOrders();
		double highestBuy, lowestSell;
		highestBuy = ((Order)buys.next()).getPrice();
		lowestSell = ((Order)sells.next()).getPrice();
		if (highestBuy >= lowestSell){
			return true;
		}
		else
			return false;
	} //end limitsOverlap()
	
	
	//Precondition:: There is at least one buy and one sell in the order book
	public boolean onlyMarkets(OrderBook ob){
		boolean ret = true;
		Iterator buys = ob.getBuyOrders();
		Iterator sells = ob.getSellOrders();
	  while(buys.hasNext()){
	  	if (!((Order)buys.next()).isMarket()){ret = false;}
	  }
	  while(sells.hasNext()){
		  if (!((Order)sells.next()).isMarket()){
		  	ret = false;
		  }
	  }
	  return ret;
}//end onlyMarkets()
	

	public double getBestOneSidePrice(OrderBook ob){
		Iterator buyOrders = ob.getBuyOrders();
		Iterator sellOrders = ob.getSellOrders();
		Order buyOrder = null, sellOrder = null, limitOrder = null;
		double limitPrice = 0.0;
		double refPrice = ob.getLastPrice();
		
		while(buyOrders.hasNext()){
			buyOrder = (Order)buyOrders.next();
			if(!buyOrder.isMarket()){
				limitPrice = buyOrder.getPrice();
				limitOrder = buyOrder;
				break;
			}//end if
		}//end while
		
		while(sellOrders.hasNext()){
			sellOrder = (Order)sellOrders.next();
			if(!sellOrder.isMarket()){
				limitPrice = sellOrder.getPrice();
				limitOrder = sellOrder;
				break;
			}//end if
		}//end while
		
		if (limitOrder instanceof BuyOrder && (limitPrice > refPrice)){
			return limitPrice;
		}
		if (limitOrder instanceof SellOrder && (limitPrice < refPrice)){
			return limitPrice;
		}
		return refPrice;
	}
	
	
//Precondition ::  There is at least one buy and one sell in the order book
	public boolean onlyMarketsOnOneSide(OrderBook ob){
		boolean buyMarketOnly = true, sellMarketOnly = true;
		Iterator buys = ob.getBuyOrders();
		Iterator sells = ob.getSellOrders();
		
		while(buys.hasNext()){
			if (!((Order)buys.next()).isMarket()){
				buyMarketOnly = false;
			}
		}
		while(sells.hasNext()){
			if (!((Order)sells.next()).isMarket()){
				sellMarketOnly = false;
			}
		}
		
		if((buyMarketOnly || sellMarketOnly) && !(buyMarketOnly && sellMarketOnly) ) {
			return true;
		}
		else{return false;}
	} //onlyMarketsOnOneSide()
			
		
	//Precondition:: There are buys and sells in the book and at least one
	// limit order on both sides
//	public double MaximumExecutionPrice(OrberBook ob){
//	  Iterator buys = ob.getBuyOrders();
//	  Iterator sells = ob.getSellOrders();
//	  //Create the cummulative least favorable price tables from the OrderIterators
//	  Hashtable	buyHashed = fillTable(buyOrders);
//	  Hashtable sellHashed = fillTable(sellOrders);
//	  
//		
//	}	
		
	//Creates the Cummulative Least Favorable price tables
	//Precondition:: Assumes the Iterator its being passed is not empty... 
//	private Vector fillTable(Iterator orderIterator){
//		boolean first = true;
//		Vector orders;
//		do {
//				tempOrder =(Order) orderIterator.next();
//
//				if{
//					price = tempOrder.getPrice();
//					first = false;
//				}
//				else { 
//					if (price != tempOrder.getPrice()){
//						Order o = new Order(cumulSize, (double)price, tempOrder.isMarket());
//						orders.addElement(o);
//						price = tempOrder.getPrice();
//						first = true;
//					}
//					
//				}
//				cumulSize += tempOrder.size();
//				if(!tempOrder.hasNext()){
//					Order o = new Order(cumulSize, (double)price, tempOrder.isMarket());
//					orders.addElement(o);
//				}
//			}while(tempOrder.hasNext());
//	}
		public double maximumExecution(OrderBook ob){
		Iterator buyOrders = ob.getBuyOrders();
		Iterator sellOrders = ob.getSellOrders();
		Order o;
		double sellProduct=0, buyProduct=0, sellAverage=0, 
			buyAverage=0, big=0, small=0, diff=0, Average=0,
			sellMarket=0, buyMarket=0;
		int sellCumul=0, buyCumul=0, smallCumul=0, bigCumul=0;
		
		o = (Order)buyOrders.next();
		
		while(o.isMarket()){
			sellMarket+=o.getSize();
			o = (Order)buyOrders.next();	
		}
		
		while(buyOrders.hasNext()){
			o = (Order)buyOrders.next();
			buyCumul += o.getSize();
			buyProduct += o.getSize()*o.getPrice();
		}
		
		buyCumul += o.getSize();
		buyProduct += o.getSize()*o.getPrice();
		buyAverage = buyProduct/(double)buyCumul;
		
		buyProduct += buyMarket*buyAverage;
		buyCumul += buyMarket;
		buyAverage = buyProduct/(double)buyCumul;
		
		o = (Order)sellOrders.next();
		while(o.isMarket()){
			sellMarket+= o.getSize();
			o = (Order)sellOrders.next();
		}
		while(sellOrders.hasNext()){
			o = (Order)sellOrders.next();
			sellCumul += o.getSize();
			sellProduct += o.getSize()*o.getPrice();
		}
		sellCumul += o.getSize();
		sellProduct += o.getSize()*o.getPrice();
		sellAverage = sellProduct/(double)sellCumul;
		
		sellProduct += sellAverage*sellMarket;
		sellCumul +=sellMarket;
		sellAverage = sellProduct/(double)sellCumul;
		
		Average = (sellProduct +buyProduct)/(double)(sellCumul+buyCumul);
			
			
	/*	if(sellCumul < buyCumul){
			smallCumul=sellCumul;
			bigCumul=buyCumul;
		}
		else{
			smallCumul=buyCumul;
			bigCumul= sellCumul;
		}
		if(sellAverage < buyAverage){
			small = sellAverage;
			big = buyAverage;
		}
		else{
			small = buyAverage;
			big = sellAverage;
		}
		diff = big - small;
		
		Average = small + diff*(smallCumul/bigCumul);
		*/
		
		System.out.println("OPENER: " + Average);
		
		return Average;
	}

}