// Exchange :: Models the behavior of an open auction type exchange environment //

package fauxExchange;

import java.util.Hashtable;
import java.util.Calendar;
import java.io.*;

class Exchange {

	//--[ Constructors ]--------------------
	//Creates a new Exchange, needs to know what segments it has
	public Exchange(Segment[] segs){
//		this.t = new Timer();
	}
	public Exchange(){}
	
	//*************************************************************//
	
	//--[ ClassData ]--------------------
//	private static Timer t;
	//*************************************************************//
	
	//--[ ClassMethods ]--------------------
	//*************************************************************//
	
	//--[ MemberData ]--------------------
	private Hashtable orderBookTable = new Hashtable();  //The collection of all OrderBooks hashed on securityId 
	private Hashtable segmentTimes = new Hashtable(); //A collection of MarketTimes hashed on segmentID
	private Segment[] segments;
	private String logFileName = "tradeLog.txt";
	private PrintStream logFilePrintStream = null;
	private boolean logTrades = false;
	
		//*************************************************************//
	
	//--[ MemberMethods ]--------------------
	//insert an order into the exchange 
	public void insertOrder(Order ord) throws InvalidSecurityIdException {
	  Integer id = new Integer(ord.getSecurityID());
	  
	  //If the OrderBookTable doesn't contain the securityID of the security that we are 
	  //working with then we throw an exception
	  if  (!orderBookTable.containsKey(id))
	    throw new InvalidSecurityIdException();
	  //Tell the OrderBook to process the order
	  else{	
	  	OrderBook ob = (OrderBook)orderBookTable.get(id);	
	    ob.insertOrder(ord);
	  }
	}
	
	//remove an order from the exchange 
	public void removeOrder(Order ord) {
		
	}
	
	public Hashtable getSegmentTimes(){
		return this.segmentTimes;
	}
	
	public void setSegments(Segment[] segs){
		this.segments = segs;
	}
	
	public Segment[] getSegments (){
		return this.segments;
	}
	
	public OrderBook[] getOrderBooks (){
		int size = orderBookTable.size();
		
		java.util.Iterator iter = orderBookTable.values().iterator();
		
		OrderBook[] books = new OrderBook[size];
		
		int i = 0;
		while (iter.hasNext()){
			books[i++] = (OrderBook)iter.next();
		}
		
		return books;
	}
	
	public void registerOrderBook (OrderBook ob){
		orderBookTable.put(new Integer(ob.getSecurity().getSecurityId()), ob);
	}
	
	void publishTrade (Trade t){
		logTrade(t);
		t.print(null);		
	}
	
	void openLog (){
		try {
			logFilePrintStream = new PrintStream(new java.io.FileOutputStream(logFileName, false));
		}catch(IOException ioe){
			ioe.printStackTrace();
		}
	}
	
	void setLogTrades (boolean log){
		this.logTrades = log;
	}
	
	void closeLog (){
		logFilePrintStream.flush();
		logFilePrintStream.close();
	}
	
	protected void logTrade(Trade t){
		if (logTrades){
			logFilePrintStream.print("EXECUTED:");
			t.print(logFilePrintStream);
		}
	}
	
	java.io.PrintStream getLogFilePrintStream () { return logFilePrintStream; }
	
	void setLogFileName(String fileName){
		this.logFileName = fileName;
	}
	
	public String getLogFileName(){
		return this.logFileName;
	}
	
	//--[ INTERFACE IMPLEMENTATION ]----------------
	//public void updateTime(){
	//  Collection c = segmentTimes.values();
	//  Iterator it = c.iterator;
	//  while(it.hasNext){
	//   Calendar current = Calendar.getInstance();
	//   MarketTime mt = it.next();
	//   Calendar start = mt.getOpenTime();
	//   Calendar close = mt.getCloseTime();
	//  
	//   int curSec = current.get(Calendar.SECOND);
	//   int curHour = current.get(Calendar.HOUR);
	//   int curMin = current.get(Calendar.MINUTE);
	//   
	//   //Get the opening Market time divisions
	//   int sSec = start.getOpenSecond();
	//   int sHour = start.getOpenHour();
	//   int sMin = start.getOpenMinute();
	//   
	//   //Get the closing Market time divisions(HMS)
	//   int cSec = close.getCloseSecond();
	//   int cHour = close.getCloseHour();
	//   int cMin = close.getCloseMinute();
	//   
	//   //if we match anyones start time...
	//   if(this.HOUR == sHour && this.SECOND == sSec && this.MINUTE == sMin){}
	//   
	//   //if we match anyone's closing time
	//   else if(this.HOUR == cHour && this.SECOND == cSec && this.MINUTE == cMin){}
	//  }
	
	public static void main (String [] args) throws Exception {
		// Create the exchange
		System.out.println("Creating Exchange...");		
		Exchange myExchange = new Exchange();
		
		// Create the Segments in this Exchange
		System.out.println("Creating Segments...");		
		Segment [] segs = new Segment[2];
		segs[0] = new Segment(myExchange, 1);
		
		// Add these Segments to the Exchange
		System.out.println("Setting Segments in Exchange...");				
		myExchange.setSegments(segs);
		
		// Create a Security
		System.out.println("Creating a Security...");				
		Security sec = new Security(1, segs[0]);
		
		// Create an OrderBook for this Security
		System.out.println("Creating an OrderBook for this Security...");				
		OrderBook ob = new OrderBook(sec);
		ob.initializePrice(94.00, 98.50);
		
		myExchange.openLog();
		myExchange.setLogTrades(true);
		
		ob.startWorker();

		myExchange.registerOrderBook(ob);
		
		System.out.println("Creating orders...");
		Order bo = new SellOrder(100, 101.00, 10001102, true, 1);
		Order bo1 = new SellOrder(100, 98.00, 10001102, true, 1);
		Order bo2 = new SellOrder(100, 99.00, 10001102, true, 1);
		Order bo3 = new SellOrder(100, 100.00, 10001102, false, 1);
		Order so = new BuyOrder(100, 96.00, 100001111, true, 1);
		Order so2 = new BuyOrder(100, 97.00, 100001119, true, 1);
		Order so3 = new BuyOrder(100, 80.00, 10003848, false, 1);
		
		try {
			myExchange.insertOrder(bo);
			myExchange.insertOrder(bo1);
			myExchange.insertOrder(bo2);
			myExchange.insertOrder(bo3);
			myExchange.insertOrder(so);	
			myExchange.insertOrder(so2);
			myExchange.insertOrder(so3);
		}catch(InvalidSecurityIdException isie){
			isie.printStackTrace();
		}
		
		ob.outputBook(null);
		
		Thread.currentThread().sleep(3000);
		
		ob.print(null);
		
		ob.printHtml(myExchange.getLogFilePrintStream());
		
		myExchange.closeLog();
	}
}