package se.lil.jm;

import java.io.IOException;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.management.InstanceNotFoundException;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.TabularData;

public class JmxMon {
	String conUser = "system";
	String conPass = "passw0rd";
	String domainName = null;
	String serverName = null;
	String runtimeName = null;
	
	int gcType = 0;
	public static final int Unknown = 0;
	public static final int CMS = 1;
	public static final int PS = 2;
	
	public boolean isGCType(int type) {
		return (gcType == type);
	}
	
	private void setGCType(int type) {
		gcType = type;
	}
	
	JMXServiceURL url = null;
	JMXConnector jmxc = null;
	MBeanServerConnection mbsc = null;
	
	Thread myThread = null;
	ClassLoader myCL = null;
	
	int getDataCalls = 0;
	int getDataSucess = 0;
	
	HashMap<String, LongDelta> longDeltaMap = new HashMap<String, LongDelta>();
	HashMap<String, DoubleDelta> doubleDeltaMap = new HashMap<String, DoubleDelta>();
	
	HashSet<String> blocked = new HashSet<String>();
	
	public void dumpDeltas() {
		System.out.println("\nLong Deltas:");
		for(String key : longDeltaMap.keySet()) {
			System.out.println("\"" + key + "\" " + longDeltaMap.get(key).getCurrentValue());
		}
		System.out.println("\nDouble Deltas:");
		for(String key : doubleDeltaMap.keySet()) {
			System.out.println("\"" + key + "\" " + doubleDeltaMap.get(key).getCurrentValue());
		}
	}
	
	private void updateLongDelta (Long timestamp, String name, Long value) {
		LongDelta ld = longDeltaMap.get(name);
		if(ld == null) {
			ld = new LongDelta();
			longDeltaMap.put(name, ld);	
		}
		ld.update(timestamp, value);
	}
	
	private LongDelta getAttributeLongDelta(String name, String attribute) {
		return longDeltaMap.get(name + ":" + attribute);
	}
	
	public LongDelta getLongDelta(String key) {
		return longDeltaMap.get(key);
	}
	
	private void updateDoubleDelta (Long timestamp, String name, Double value) {
		DoubleDelta dd = doubleDeltaMap.get(name);
		if(dd == null) {
			dd = new DoubleDelta();
			doubleDeltaMap.put(name, dd);
		}
		dd.update(timestamp, value);
	}
	
	private DoubleDelta getAttributeDoubleDelta(String name, String attribute) {
		return doubleDeltaMap.get(name + ":" + attribute);
	}
	
	public DoubleDelta getDoubleDelta(String key) {
		return doubleDeltaMap.get(key);
	}
	
	private Object getAttributeValue(String name, String attribute) {
		Object ro = null;
		if(mbsc != null) {
			try {
				if(!blocked.contains(name))	ro = mbsc.getAttribute(new ObjectName(name), attribute);
			} catch (InstanceNotFoundException ie) {
				blocked.add(name);
			} catch (Exception e) {
			}
		}
		return ro;
	}
	
	String lastKeyName = "";
	
	private void updateCompositeDelta (Long timestamp, String name, CompositeData data) {
		for(String key : data.getCompositeType().keySet()) {
			String fullName;
			if(key.equals("value")) fullName = name + ":" + lastKeyName;
			else fullName = name + ":" + key;
			Object obj = data.get(key);
			updateDelta(timestamp, fullName, obj);
		}
	}
	
	private void updateTabularDelta (Long timestamp, String name, TabularData data) {
		for(Object obj : data.values()) {
			CompositeData cd = (CompositeData)obj;
			updateCompositeDelta(timestamp, name, cd);
		}
	}
	
	private void updateDelta(Long timestamp, String fullName, Object data) {
		if(data != null) {
			if(data.getClass().equals(java.lang.String.class)) {
				lastKeyName = (String)data;
			} else
			if(data.getClass().equals(java.lang.Long.class)) {
				updateLongDelta(timestamp, fullName, (Long)data);
			} else
			if(data.getClass().equals(java.lang.Integer.class)) {
				Integer i = (Integer)data;
				updateLongDelta(timestamp, fullName, i.longValue());
			} else
			if(data.getClass().equals(java.lang.Double.class)) {
				updateDoubleDelta(timestamp, fullName, (Double)data);
			} else
			if(data.getClass().equals(java.lang.Float.class)) {
				Float f = (Float)data;
				updateDoubleDelta(timestamp, fullName, f.doubleValue());
			} else
			if(data.getClass().equals(javax.management.openmbean.CompositeDataSupport.class)) {
				updateCompositeDelta(timestamp, fullName, (CompositeData)data);
			} else
			if(data.getClass().equals(javax.management.openmbean.TabularDataSupport.class)) {
				updateTabularDelta(timestamp, fullName, (TabularData)data);
			} else {
				System.out.println("Received Unknown Object: " + data.getClass());
			}
		}
	}
	
	private void fetchUpdateAttribute(String name, String attribute) {
		String fullName = name + ":" + attribute;
		Object obj = getAttributeValue(name, attribute);
		if(obj != null) {
			Long ts = (Long)getAttributeValue("java.lang:type=Runtime", "Uptime");
			updateDelta(ts, fullName, obj);
		}
	}
	
	public int getDataCalled() {
		return getDataCalls;
	}
	
	public int getDataSucceeded() {
		return getDataSucess;
	}
	
	public int getDataFailed() {
		return getDataCalls - getDataSucess;
	}
	
	public String getConString() {
		if(this.url != null) return this.url.toString();
		else return null;
	}
	
	public String getServerName() {
		return serverName;
	}
	
	public String getDomainName() {
		return domainName;
	}
	
	public String getRuntimeName() {
		return runtimeName;
	}
	
	public void open() throws IOException {
		if(url != null) {
			jmxc = JMXConnectorFactory.connect(url);
			mbsc = jmxc.getMBeanServerConnection();
			domainName = mbsc.getDefaultDomain();
			Object obj = getAttributeValue("java.lang:type=Runtime", "Name");
			if(obj.getClass().equals(java.lang.String.class)) {
				runtimeName = (String)obj;
			}
			obj = getAttributeValue("java.lang:type=Runtime", "SystemProperties");
			TabularData td = (TabularData)obj;
			for (Object o : td.values()) {
				CompositeData d = (CompositeData)o;
				if(d.get("key").toString().equals("weblogic.Name")) serverName = d.get("value").toString();
			}
		}
	}
	
	public void open(String serviceURL) throws IOException, MalformedURLException {
		url = new JMXServiceURL(serviceURL);
		open();
	}
	
	public void close() throws IOException {
		if(jmxc != null) jmxc.close();
		jmxc = null;
		mbsc = null;
	}
	
	long lastRTns = 0;
	public long getLastRTms() {
		return lastRTns / (1000 * 1000);
	}
	
	long lastFetchTSns = 0;
	public boolean getData(long ageTs) throws Throwable {
		if (getAgeTs() > ageTs ) return getData();
		else return false;
	}
	
	public long getAgeTs() {
		if(lastFetchTSns > 0) return (System.nanoTime() - lastFetchTSns)/(1000*1000*1000);
		else return 0;
	}
	
	Lock lock = new ReentrantLock();
	
	public boolean getData() throws Throwable {
		// Start thread safe
 		// Try to get a lock
 		boolean haveLock = lock.tryLock();
		if( haveLock == false) {
			// We could not get the lock, someone else is updating. Wait for it to complete by waiting for a lock, then unlock and return.
			try {
				lock.lock();
			} finally {
				lock.unlock();
			}
			return false;
		}
		// We do have the lock. Do the rest in a try catch everything and if we catch anything, re throw the catch but always release the lock.
		try {
			long startTSns = System.nanoTime();
	 		getDataCalls++;
	 		// Do the update of data
	 		numCpus = (Integer)getAttributeValue("java.lang:type=OperatingSystem", "AvailableProcessors");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "ProcessCpuTime");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "OpenFileDescriptorCount");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "MaxFileDescriptorCount");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "TotalSwapSpaceSize");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "FreeSwapSpaceSize");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "FreePhysicalMemorySize");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "TotalPhysicalMemorySize");
	 		fetchUpdateAttribute("java.lang:type=OperatingSystem", "SystemLoadAverage");
	 		fetchUpdateAttribute("java.lang:type=Threading", "ThreadCount");
	 		fetchUpdateAttribute("java.lang:type=ClassLoading", "LoadedClassCount");
	 		fetchUpdateAttribute("java.lang:type=Memory", "HeapMemoryUsage");
	 		
	 		// Only get theese if we have the right GC type
	 		if(isGCType(JmxMon.Unknown) || isGCType(JmxMon.PS)) {
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=PS MarkSweep", "LastGcInfo");
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=PS MarkSweep", "CollectionTime");
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=PS Scavenge", "CollectionTime");
		 		fetchUpdateAttribute("java.lang:type=MemoryPool,name=PS Old Gen", "Usage");
	 		}
	 		if(isGCType(JmxMon.Unknown) || isGCType(JmxMon.CMS)) {
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep", "LastGcInfo");
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep", "CollectionTime");
		 		fetchUpdateAttribute("java.lang:type=GarbageCollector,name=ParNew", "CollectionTime");
		 		fetchUpdateAttribute("java.lang:type=MemoryPool,name=CMS Old Gen", "Usage");
	 		}
	 		// Finished updating data
	 		getDataSucess++;
			lastFetchTSns = System.nanoTime();
			lastRTns = lastFetchTSns - startTSns;
			
			// Check the GC type if not known
			if(isGCType(JmxMon.Unknown)) {
				if(longDeltaMap.containsKey("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:CollectionTime")) setGCType(JmxMon.CMS);
				if(longDeltaMap.containsKey("java.lang:type=GarbageCollector,name=PS MarkSweep:CollectionTime")) setGCType(JmxMon.PS);
			}
			return true;
		} catch (Throwable e) {
			throw (e);
		} finally {
			lock.unlock();
		}
		// End thread safe
	}
	
	//NUM_CPUS
	int numCpus = 0;
	public long getNumberOfCPUs() {
		return numCpus;
	}
	
	public long getLoadedClassCount() {
		LongDelta ld = getAttributeLongDelta("java.lang:type=ClassLoading", "LoadedClassCount");
		return ld.getCurrentValue();
	}
	
	public double getCPUPercent() {
		LongDelta ld = getAttributeLongDelta("java.lang:type=OperatingSystem", "ProcessCpuTime");
		double cpuDeltaMS = (double)ld.getDelta() / (1000D*1000D);
		double spentMS = ld.getMilliSeconds();
		double perCPUMS = cpuDeltaMS / (double)numCpus;
		double cpuPct = (perCPUMS / spentMS) * 100D;
		return cpuPct;
	}
	
	public double getAverageLoad() {
		DoubleDelta dd = getAttributeDoubleDelta("java.lang:type=OperatingSystem", "SystemLoadAverage");
		return dd.getCurrentValue();
	}
	
	public double getAverageLoadPerCpu() {
		DoubleDelta dd = getAttributeDoubleDelta("java.lang:type=OperatingSystem", "SystemLoadAverage");
		return dd.getCurrentValue()/(double)numCpus;
	}
	
	public long getThreads() {
		LongDelta ld = getAttributeLongDelta("java.lang:type=Threading", "ThreadCount");
		return ld.getCurrentValue();
	}
	
	public double getSystemMemoryPercentUsed() {
		LongDelta ldf = getAttributeLongDelta("java.lang:type=OperatingSystem", "FreePhysicalMemorySize");
		LongDelta ldt = getAttributeLongDelta("java.lang:type=OperatingSystem", "TotalPhysicalMemorySize");
		double free = ldf.getCurrentValue();
		double total = ldt.getCurrentValue();
		return ((total - free)/(total)) * 100D;
	}
	
	public double getSystemSwapPercentUsed() {
		LongDelta ldf = getAttributeLongDelta("java.lang:type=OperatingSystem", "FreeSwapSpaceSize");
		LongDelta ldt = getAttributeLongDelta("java.lang:type=OperatingSystem", "TotalSwapSpaceSize");
		double free = ldf.getCurrentValue();
		double total = ldt.getCurrentValue();
		return ((total - free)/(total)) * 100D;
	}
	
	public double getSystemFileDescriptorsPercentUsed() {
		LongDelta ldo = getAttributeLongDelta("java.lang:type=OperatingSystem", "OpenFileDescriptorCount");
		LongDelta ldm = getAttributeLongDelta("java.lang:type=OperatingSystem", "MaxFileDescriptorCount");
		double open = ldo.getCurrentValue();
		double max = ldm.getCurrentValue();
		return (open/max) * 100D;
	}
	
	public double getHeapUsedMB() {
		LongDelta ld = getLongDelta("java.lang:type=Memory:HeapMemoryUsage:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getHeapUsedPercent() {
		LongDelta ldu = getLongDelta("java.lang:type=Memory:HeapMemoryUsage:used");
		LongDelta ldm = getLongDelta("java.lang:type=Memory:HeapMemoryUsage:max");
		if(ldu != null && ldm != null) {
			return ((double)ldu.getCurrentValue()/(double)ldm.getCurrentValue()) * 100D;
		} else {
			return 0;
		}
	}
	
	public double getHeapAllocationRateMBps() {
		LongDelta ldu = getLongDelta("java.lang:type=Memory:HeapMemoryUsage:used");
		if(ldu != null) {
			if(ldu.getPerSecondValue() > 0) {
				return ldu.getPerSecondValue()/(1024D*1024D);
			} else {
				// negative delta, means we had a major GC in the delta, get the last heap size before GC and add it to the last (previous) value
				Long beforeGC = null;
				if(isGCType(JmxMon.CMS)) {
					LongDelta ld1 = getLongDelta("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:LastGcInfo:memoryUsageBeforeGc:CMS Old Gen:used");
					LongDelta ld2 = getLongDelta("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:LastGcInfo:memoryUsageBeforeGc:Par Eden Space:used");
					LongDelta ld3 = getLongDelta("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:LastGcInfo:memoryUsageBeforeGc:Par Survivor Space:used");
					if(ld1 != null && ld2 != null && ld3 != null)
						beforeGC = ld1.getCurrentValue() +	ld2.getCurrentValue() +	ld3.getCurrentValue();
				} else
				if(isGCType(JmxMon.PS)) {
					LongDelta ld1 = getLongDelta("java.lang:type=GarbageCollector,name=PS MarkSweep:LastGcInfo:memoryUsageBeforeGc:PS Old Gen:used");
					LongDelta ld2 = getLongDelta("java.lang:type=GarbageCollector,name=PS MarkSweep:LastGcInfo:memoryUsageBeforeGc:PS Eden Space:used");
					LongDelta ld3 = getLongDelta("java.lang:type=GarbageCollector,name=PS MarkSweep:LastGcInfo:memoryUsageBeforeGc:PS Survivor Space:used");
					if(ld1 != null && ld2 != null && ld3 != null)
						beforeGC = 	ld1.getCurrentValue() +	ld2.getCurrentValue() +	ld3.getCurrentValue();
				}
				if(beforeGC == null) return 0;
				if(ldu.lastValue == null) return 0;
				ldu.lastValue = beforeGC + ldu.lastValue;
				System.out.println("Adjusted heap size with " + beforeGC + " bytes");
				return ldu.getPerSecondValue()/(1024D*1024D);
			}
		} else {
			return 0;
		}
	}
	
	public double getPSOldGenUsedMB() {
		LongDelta ld = getLongDelta("java.lang:type=MemoryPool,name=PS Old Gen:Usage:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getCMSOldGenUsedMB() {
		LongDelta ld = getLongDelta("java.lang:type=MemoryPool,name=CMS Old Gen:Usage:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getPSOldGenUsedPercent() {
		LongDelta ldu = getLongDelta("java.lang:type=MemoryPool,name=PS Old Gen:Usage:used");
		LongDelta ldm = getLongDelta("java.lang:type=MemoryPool,name=PS Old Gen:Usage:max");
		if(ldu != null && ldm != null) {
			return ((double)ldu.getCurrentValue()/(double)ldm.getCurrentValue()) * 100D;
		} else {
			return 0;
		}
	}
	
	public double getCMSOldGenUsedPercent() {
		LongDelta ldu = getLongDelta("java.lang:type=MemoryPool,name=CMS Old Gen:Usage:used");
		LongDelta ldm = getLongDelta("java.lang:type=MemoryPool,name=CMS Old Gen:Usage:max");
		if(ldu != null && ldm != null) {
			return ((double)ldu.getCurrentValue()/(double)ldm.getCurrentValue()) * 100D;
		} else {
			return 0;
		}
	}
	
	public double getPSMarkSweepOldGenAfterGCMB() {
		LongDelta ld = getLongDelta("java.lang:type=GarbageCollector,name=PS MarkSweep:LastGcInfo:memoryUsageAfterGc:PS Old Gen:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getCMSMarkSweepOldGenAfterGCMB() {
		LongDelta ld = getLongDelta("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:LastGcInfo:memoryUsageAfterGc:CMS Old Gen:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getPSMarkSweepPermGenAfterGCMB() {
		LongDelta ld = getLongDelta("java.lang:type=GarbageCollector,name=PS MarkSweep:LastGcInfo:memoryUsageAfterGc:PS Perm Gen:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public double getCMSMarkSweepPermGenAfterGCMB() {
		LongDelta ld = getLongDelta("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep:LastGcInfo:memoryUsageAfterGc:CMS Perm Gen:used");
		if(ld != null) {
			return (double)ld.getCurrentValue() / (1024D*1024D);
		} else {
			return 0;
		}
	}
	
	public JmxMon() {
	}
	
	public JmxMon(String serviceURL) throws MalformedURLException {
		this.url = new JMXServiceURL(serviceURL);
	}
}