/*
    * $Id$
    *
    * Copyright 2006 Commsen International
    * 
    * Licensed under the Common Public License, Version 1.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
   *      http://www.opensource.org/licenses/cpl1.0.txt
   * 
   * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
   * EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS 
   * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
   *
   */
  package com.commsen.stopwatch.storages;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  
  import com.commsen.stopwatch.StopwatchStorage;
  import com.commsen.stopwatch.StopwatchStorageException;
  
  /***
   * TODO Dokumentacja
   * 
   * @author Milen Dyankov
   * 
   */
  public class StorageManager implements Runnable {
  
  	private static final Logger log = Logger.getLogger(StorageManager.class);
  
  	private static final int SLEEP_TIME = 10;
  
  	final static int ADD = 0;
  	final static int UPDATE = 1;
  	final static int REMOVE = 2;
  
  	/***
  	 * Storage manager will insert record into database when "start" method is called and update it
  	 * when "stop" method is called. NOTE: in this case the time taken to insert the record into
  	 * database is added to measurements.
  	 */
  	public static final int NORMAL_MODE = 0;
  
  	/***
  	 * Same as {@link #NORMAL_MODE} but storage manager runs in separate thread, thus resulting in
  	 * more correct measurements. NOTE: in this case getReport(...) methods may return null when
  	 * called soon after "stop" since storage manager may have not managed to store its data.
  	 */
  	public static final int THREAD_MODE = 1;
  
  	/***
  	 * Storage manager keeps in memory data gathered on "start" and stores all together when "end"
  	 * is called.
  	 */
  	public static final int DELAYED_MODE = 2;
  
  	/***
  	 * 
  	 */
  	private StopwatchStorage storage;
  
  	/***
  	 * 
  	 */
  	private LinkedList toBeProcessed;
  
  	/***
  	 * 
  	 */
  	private Map idMapping;
  
  	long id = 0;
  
  	boolean running;
  
  	int mode;
  
  	private Thread[] threadPool;
  
  	int runningThreads;
  
  
  	/***
  	 * @param storage
  	 * @param threadMode
  	 * 
  	 */
  	public StorageManager(StopwatchStorage storage, int threadMode) {
  		threadPool = new Thread[1];
  		toBeProcessed = new LinkedList();
  		idMapping = Collections.synchronizedMap(new HashMap());
 		this.storage = storage;
 		this.mode = threadMode;
 		runningThreads = 0;
 	}
 
 
 	/***
 	 * 
 	 * 
 	 */
 	public synchronized void start() {
 		doStart(false);
 	}
 
 
 	/***
 	 * 
 	 * @see com.commsen.stopwatch.StopwatchEngine#resume()
 	 */
 	public synchronized void resume() {
 		doStart(true);
 	}
 
 
 	/***
 	 * 
 	 * @param isRestart
 	 */
 	private void doStart(boolean isRestart) {
 		if (running) return;
 
 		try {
 			if (isRestart)
 				storage.unfreeze();
 			else
 				storage.open();
 		} catch (StopwatchStorageException e) {
 			log.warn("Could not initialize stopwatch storage", e);
 			return;
 		}
 
 		running = true;
 
 		if (mode == THREAD_MODE) {
 			for (int i = 0; i < threadPool.length; i++) {
 				threadPool[i] = new Thread(this, "Stopwatch storage manager " + i);
 				threadPool[i].setDaemon(true);
 				threadPool[i].start();
 			}
 		}
 	}
 
 
 	/***
 	 * 
 	 * 
 	 */
 	public synchronized void stop() {
 		doStop(false);
 	}
 
 
 	/***
 	 * 
 	 * 
 	 */
 	public synchronized void pause() {
 		doStop(true);
 	}
 
 
 	/***
 	 * 
 	 * @param isPause
 	 */
 	private void doStop(boolean isPause) {
 		running = false;
 
 		while (runningThreads > 0) {
 			try {
 				Thread.sleep(SLEEP_TIME);
 			} catch (InterruptedException e) {
 				// wake up
 			}
 		}
 
 		try {
 			if (isPause)
 				storage.freeze();
 			else
 				storage.close();
 		} catch (StopwatchStorageException e) {
 			log.warn("Storage error", e);
 		}
 	}
 
 
 	/***
 	 * @see java.lang.Runnable#run()
 	 */
 	public void run() {
 		runningThreads++;
 		while (running) {
 			try {
 				Thread.sleep(SLEEP_TIME);
 			} catch (InterruptedException e) {
 				// wake up
 			}
 			processItems();
 		}
 		runningThreads--;
 	}
 
 
 	/***
 	 * 
 	 * @param parameters
 	 * @return
 	 */
 	public long newRecord(Object[] parameters) {
 		switch (mode) {
 			case NORMAL_MODE:
 				synchronized (this) {
 					processSingleItem(++id, ADD, parameters);
 					return id;
 				}
 
 			case THREAD_MODE:
 				synchronized (toBeProcessed) {
 					toBeProcessed.addLast(new BufferItem(++id, ADD, parameters));
 					return id;
 				}
 
 			case DELAYED_MODE:
 				synchronized (idMapping) {
 					idMapping.put(new Long(++id), parameters);
 					return id;
 				}
 		}
 		return -1;
 	}
 
 
 	/***
 	 * 
 	 * @param id
 	 * @param parameters
 	 * @return
 	 */
 	public boolean completeRecord(long id, Object[] parameters) {
 
 		switch (mode) {
 			case NORMAL_MODE:
 				synchronized (this) {
 					return processSingleItem(id, UPDATE, parameters);
 				}
 
 			case THREAD_MODE:
 				synchronized (toBeProcessed) {
 					toBeProcessed.addLast(new BufferItem(id, UPDATE, parameters));
 					return true;
 				}
 
 			case DELAYED_MODE:
 				synchronized (idMapping) {
 					Object[] startParameters = (Object[]) idMapping.remove(new Long(id));
 					if (startParameters == null) return false;
 					try {
 						storage.newCompleteRecord(startParameters, parameters);
 					} catch (StopwatchStorageException e) {
 						log.warn("Storage error", e);
 						return false;
 					}
 					return true;
 				}
 		}
 		return false;
 
 	}
 
 
 	/***
 	 * 
 	 * @param id
 	 * @return
 	 */
 	public boolean removeRecord(long id) {
 
 		switch (mode) {
 			case NORMAL_MODE:
 				synchronized (this) {
 					return processSingleItem(id, REMOVE, null);
 				}
 
 			case THREAD_MODE:
 				synchronized (toBeProcessed) {
 					toBeProcessed.addLast(new BufferItem(id, REMOVE, null));
 					return true;
 				}
 
 			case DELAYED_MODE:
 				synchronized (idMapping) {
 					return idMapping.remove(new Long(id)) != null;
 				}
 		}
 		return false;
 
 	}
 
 
 	/***
 	 * 
 	 * 
 	 */
 	private void processItems() {
 		BufferItem bufferItem = null;
 		synchronized (toBeProcessed) {
 			if (!toBeProcessed.isEmpty()) bufferItem = (BufferItem) toBeProcessed.removeFirst();
 		}
 
 		while (bufferItem != null) {
 			processSingleItem(bufferItem.id, bufferItem.operation, bufferItem.parameters);
 
 			synchronized (toBeProcessed) {
 				if (!toBeProcessed.isEmpty())
 					bufferItem = (BufferItem) toBeProcessed.removeFirst();
 				else
 					bufferItem = null;
 			}
 
 		}
 
 	}
 
 
 	/***
 	 * @param id
 	 * @param operation
 	 * @param parameters
 	 * @param bufferItem
 	 */
 	private boolean processSingleItem(long id, int operation, Object[] parameters) {
 		long databaseID;
 		Object dbKey;
 		try {
 			switch (operation) {
 				case ADD:
 					databaseID = storage.newRecord(parameters);
 					idMapping.put(new Long(id), new Long(databaseID));
 					return true;
 
 				case UPDATE:
 					dbKey = idMapping.remove(new Long(id));
 					if (dbKey == null) return false;
 					databaseID = ((Long) dbKey).longValue();
 					storage.completeRecord(databaseID, parameters);
 					return true;
 
 				case REMOVE:
 					dbKey = idMapping.remove(new Long(id));
 					if (dbKey == null) return false;
 					databaseID = ((Long) dbKey).longValue();
 					storage.removeRecord(databaseID);
 					return true;
 
 			}
 		} catch (StopwatchStorageException e) {
 			log.warn("Storage error", e);
 		}
 		return false;
 	}
 
 	/***
 	 * 
 	 * TODO Dokumentacja
 	 * 
 	 * @author Milen Dyankov
 	 * 
 	 */
 	static class BufferItem {
 
 		long id;
 
 		int operation;
 
 		Object[] parameters;
 
 
 		/***
 		 * @param id
 		 * @param operation
 		 * @param parameters
 		 */
 		public BufferItem(long id, int operation, Object[] parameters) {
 			this.id = id;
 			this.operation = operation;
 			this.parameters = parameters;
 		}
 
 	}
 
 }