/*
 * todo: 
 * - results so abholen, dass gleich die einzenlen dateien verlinkt werden können und aufs handy gepusht werden
 * - in eine datei die aktuellen ergebnisse zwischenspeichern serilized, bei jedem start einlesen ( key=SESSIONID, VALUE=XMLRESULTSTRING )
 * - polling beim server einbauen
 * - im fehlerfall thread stoppen und neuen thread starten oder externe anwendung startet im fehlerfall neu
 * - lockfile support, run only one instance: http://stackoverflow.com/questions/177189/how-to-implement-a-single-instance-java-application
 * http://download.oracle.com/javase/tutorial/essential/concurrency/simple.html
 */
package buzzerproxy;

import buzzerproxy.bprot.ByteProtServer;
import buzzerproxy.handler.ExceptionHandler;
import buzzerproxy.handler.QuestionInterface;
import buzzerproxy.CacheManager;
import buzzerproxy.db.DatabaseManager;
import buzzerproxy.db.view.DatabaseEntry;

import java.util.logging.Level;
import java.util.logging.Logger;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * 
 * @author thecerial
 */
public class BuzzerProxy implements ExceptionHandler, QuestionInterface {

	private String BuzzerProxyVersion = "1.1.a - 12.8.2011";
	private String Version = "www.buzzerstar.com"
			+ " / BuzzerProxyJar Version -" + BuzzerProxyVersion
			+ " running on localhost on Port " + Constant.SERVER_PORT;
	private String xmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
			+ "<search>"
			+ "<servicetyp>find</servicetyp>"
			+ "<searchquery>Madonna</searchquery>"
			+ "<filetyp>.mp3+.wav+.flac</filetyp>"
			+ "<session>23232323232323232323232323</session>"
			+ "<clientversion>1.0.1</clientversion>"
			+ "<clientid>2429545b007ffc86a98df6f3cab76fc4</clientid>"
			+ "</search>" + "</xml>";
	private XMLParser XMLParser = null;
	private CacheManager cacheManager;
	private DatabaseManager databaseManager;
	private IO io = new IO();
	
	/**
     */
	private BuzzerProxy() {
		// Server mit Byte Protokol
		System.out.println(Version);
		new ByteProtServer(Constant.SERVER_PORT, this/* QuestionInterface */, this/* ExceptionHandler */)
				.start();
		new IO().lockInstance();
		// new ServerThread().start();

	}

//	final class ServerThread extends Thread {
//
//		@Override
//		public void run() {
//
//			String decryptedGzipXMLContent = "";
//			String xmlContent = "";
//			String googleResultString = "";
//			HashMap<String, String> results = null;
//			String clientid = null;
//			String clientversion = null;
//			String searchservice = null;
//			String searchquery = null;
//			String page = null;
//			String filetyp = null;
//			String cryptedResults = null;
//
//			BufferedReader inFromServer = null;
//			DataOutputStream outToClient = null;
//
//			try {
//				server = new ServerSocket(ServerPort);
//
//			} catch (IOException ex) {
//				Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
//						null, ex);
//			}
//
//			// System.out.println(this);
//			// this.clone();
//
//			// System.exit(9);
//
//			while (this.isAlive()) {
//
//				try {
//
//					client = server.accept();
//					String clientIPAdress = client.getInetAddress().toString();
//					System.out.println("[" + clientIPAdress + "]"
//							+ " Client Connected");
//
//					// timer = new Timer( timeout, client );
//
//					try {
//
//						client.setKeepAlive(true);
//						// client.setSoTimeout(timeout);
//						client.setTrafficClass(0x04);
//						client.setTcpNoDelay(true);
//
//					} catch (Exception x) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, x);
//					} finally {
//					}
//
//					inFromServer = new BufferedReader(new InputStreamReader(
//							client.getInputStream()));
//					outToClient = new DataOutputStream(client.getOutputStream());
//					// outToClient.writeUTF("DEBUG: Welcome to " + Version);
//
//					try {
//						String userInput = null;
//						// cryptedResults = inFromServer.readLine();
//						while ((userInput = inFromServer.readLine()) != null) {
//							cryptedResults += userInput;
//						}
//					} catch (Exception e) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, e);
//					}
//
//					// if ( timer.isTimeout == true ) {
//					// System.out.println( "Got Timeout" );
//					// }
//
//					try {
//					} catch (NullPointerException n) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, n);
//						client.close();
//					} catch (Exception n) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, n);
//						client.close();
//					} finally {
//						// System.out.println("Beende mich");
//						// System.exit(1);
//						// client.close();
//						// this.interrupted();
//					}
//
//					System.out.println("Got from Client: "
//							+ cryptedResults.toString());
//					if (cryptedResults.equalsIgnoreCase("exit")) {
//						outToClient
//								.writeUTF("BuzzerProxy closing Client Socket Connection because of Termination Request");
//						client.close();
//					} // if (cryptedResults.equalsIgnoreCase("exit")) {
//
//					// //// try { // Decrypt
//					// //// decryptedGzipXMLContent =
//					// Crypto.performDecrypt(secredCryptoKey.getBytes(),
//					// cryptedResults.toString());
//					// //// } catch (Exception ex) {
//					// ////
//					// System.out.println("Es gab probleme beim Decrypten der Nachricht.");
//					// ////
//					// Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
//					// null, ex);
//					// //// }
//					// ////
//					// //// try { // Gunzip
//					// //// xmlContent =
//					// Gzip.gunzipString(decryptedGzipXMLContent);
//					// //// } catch (IOException ioex) {
//					// ////
//					// Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
//					// null, ioex);
//					// //// }
//
//					try {
//						results = XMLParser.parseResults(xmlContent);
//						clientid = results.get(XMLParser.CLIENT_ID);
//						clientversion = results.get(XMLParser.CLIENT_VERSION);
//						searchservice = results.get(XMLParser.SEARCH_SERVICE);
//						searchquery = results.get(XMLParser.SEARCH_QUERY);
//						page = results.get(XMLParser.RESULT_PAGE);
//						filetyp = results.get(XMLParser.FILE_TYP);
//					} catch (NullPointerException n) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, n);
//						// client.close();
//					}
//
//					String output = "##############################################################\n"
//							+ "Client IP:          "
//							+ clientIPAdress
//							+ "\n"
//							+ "Client ID:          "
//							+ clientid
//							+ "\n"
//							+ "Client Version:     "
//							+ clientversion
//							+ "\n"
//							+ "Client Service:     "
//							+ searchservice
//							+ "\n"
//							+ "Client Query:       "
//							+ searchquery
//							+ "\n"
//							+ "Client Page:        "
//							+ page
//							+ "\n"
//							+ "Client FileTyp:     " + filetyp + "\n";
//
//					/**
//					 * Nimm den Request vom Client entgegegn und sende ihm eine
//					 * 32 Bittige Session ID
//					 */
//					try { // Send Google Request
//						if (IO.isSet(searchservice) && IO.isSet(clientid)) {
//							if (searchservice.equalsIgnoreCase("find")
//									&& clientid.equals(SECRET_AUTH_KEY)) {
//
//								long sessionID = System.currentTimeMillis();// Crypto.generateSessionID();
//								String sessionXML = CommunicationProtocol
//										.sessionXML(sessionID);
//								outToClient.writeUTF(sessionXML);
//								client.close();
//
//							} // if ( searchservice.equalsIgnoreCase("find") &&
//								// clientid.equals(SECRET_AUTH_KEY)) {
//						} // if ( IO.isSet(searchservice) && IO.isSet(clientid)
//							// {
//					} catch (Exception ex) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, ex);
//						// client.close();
//					}
//
//					try {
//
//						if (IO.isSet(searchquery)
//								&& IO.isSet(filetyp)
//								&& (searchservice.equalsIgnoreCase("results") && clientid
//										.equals(SECRET_AUTH_KEY))) {
//
//							googleResultString = Google.getGoogleContent(
//									searchquery, filetyp);
//							ArrayList<ResultContainer> ResultXMLString = GoogleResultParser
//									.parseResults(googleResultString, filetyp);
//							outToClient.writeUTF("ResultXMLString");
//							client.close();
//
//							output += "Client Google JSON: "
//									+ googleResultString + "\n";
//							output += "Client Results:     " + ResultXMLString
//									+ "\n";
//							output += "##############################################################"
//									+ "\n";
//
//							System.out.println(output);
//							Logging.appendFile(output);
//
//						}// if (IO.isSet(searchquery) && IO.isSet(filetyp) &&
//							// (searchservice.equalsIgnoreCase("results") &&
//							// clientid.equals(SECRET_AUTH_KEY)) )
//
//					} catch (Exception ex) {
//						Logger.getLogger(BuzzerProxy.class.getName()).log(
//								Level.SEVERE, null, ex);
//						// client.close();
//					}
//
//				} catch (IOException ex) {
//					Logger.getLogger(BuzzerProxy.class.getName()).log(
//							Level.SEVERE, null, ex);
//				}
//
//				// Reset the timer
//				// timer.reset();
//
//			} // while (true) {
//		} // public void run() {
//	} // final class ServerThread extends Thread {
//
//	public void stop() {
//		try {
//			server.close();
//			client.close();
//		} catch (IOException ex) {
//			Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
//					null, ex);
//			System.out.println("Fange IOException ab");
//		} catch (NullPointerException nex) {
//			Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
//					null, nex);
//			System.out.println("Fange Nullpointer ab");
//		}
//		System.out.println("Bin in der Stop Methode angekommen");
//	}

	/**
	 * @param args
	 *            the command line arguments
	 */
	public static void main(String[] args) {
		// TODO code application logic here
		new BuzzerProxy();

	} // public static void main(String[] args) {

	@Override
	public void throwException(Throwable throwable) {
		throwable.printStackTrace();
	}

	@Override
	public ArrayList<ResultContainer> request(String xmlRequest)
			throws Exception {

		if (cacheManager == null)
			cacheManager = new CacheManager();
		
		// muss immer neu erstellt werden, da er das Session Management von Hibernate verwaltet 
		// und nach jedem Query die Hibernate Session geschlossen wird
		databaseManager = new DatabaseManager();
	
		HashMap<String, String> results = null;
		String clientid = null;
		String clientversion = null;
		String searchservice = null;
		String searchquery = null;
		String page = null;
		String filetype = null;

		try {
			results = XMLParser.parseResults(xmlRequest);
			clientid = results.get(Constant.CLIENT_ID);
			clientversion = results.get(Constant.CLIENT_VERSION);
			searchservice = results.get(Constant.SEARCH_SERVICE);
			searchquery = results.get(Constant.SEARCH_QUERY);
			page = results.get(Constant.RESULT_PAGE);
			filetype = results.get(Constant.FILE_TYP);
		} catch (NullPointerException n) {
			Logger.getLogger(BuzzerProxy.class.getName()).log(Level.SEVERE,
					null, n);
		}
		if (clientid == null || clientversion == null || searchservice == null
				|| searchquery == null || page == null || filetype == null) {
			throw new NullPointerException();
		}

		// hole aus dem Manager die Ergebnisse 
		ArrayList<ResultContainer> rt = cacheManager.getResultContainerFor(searchquery, filetype);
		
		DatabaseEntry dblog = new DatabaseEntry();
			dblog.setclientversion(clientversion);
			dblog.setfiletype(filetype);
			dblog.setid("");
			dblog.setip("TODO");
			dblog.setresultcount( rt.size()+"" );
			dblog.setsearch(searchquery);
			dblog.settype("TODO");
			dblog.setdatetime("");
		
		if ( !databaseManager.query(dblog) ) 
			io.writeLog(dblog);
		
		return rt;
	}

	@Override
	public String getConfigXMLVersion() {
		XMLParser xml = new XMLParser();
		String xmlConfiguration = getConfigurationXML();
		HashMap<String,String> r = xml.parseResults(xmlConfiguration);
		if ( r.containsKey(Constant.XML_VERSION)){
			return r.get(Constant.XML_VERSION);
		} else {
			return Constant.XML_CURRENT_VERSION;
		}
	}

	@Override
	public String getConfigurationXML() {
		String rContent = null;
		try {
			rContent = io.readFileAsString(Constant.XML_PATH);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rContent;
	}

}