package com.sitech.ismp.coll;

import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;

import org.apache.log4j.Logger;

import com.sitech.ismp.app.coll.RPCTarget;
import com.sitech.util.Formater;

/**
 * 
 * 
 * @author winnerbao
 * 
 */
public class CollCompaqWithCMD {

	private Logger logger = Logger.getLogger("COLL");

	String PRE_UNITID = "10-10-27"; // Compaq���ı�ʶ

	RPCTarget rpctarget = null;

	/**
	 * @param params
	 * @return
	 */
	public Vector getConfig(HashMap params) {
		try {
			logger.info("begin getConfig");

			init(params);

			// ����ɼ��������ֵ
			CollBase collResult = new CollBase();

			// �������õ���kpiֵ��unit_id,����PRE_UNITID + "-10"��ͷ�����Total���
			String config_PRE_UNITID = PRE_UNITID + "-10"; // totalֵ

			// ��ȡ������
			Vector host = rpctarget.getKPISet("/usr/bin/uname -a");

			String host_name = (String) host.elementAt(0);
			host_name = collResult.split(host_name, 1);
			// �õ�unit_id��ʹ�õ�������
			String neat_host_name = Formater.neatenunitid(host_name);

			// ��Ӳɼ�ʱ��ָ��
			String pattern = "yyyy-MM-dd-HH-mm-ss";
			SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-22", dateFormat
					.format(new java.util.Date()));

			// ����ip,���ڸ澯����
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-50", (String) params
					.get("IP_ADDR"));

			String value = ""; // ��ʱ��

			// ������
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-01", host_name);

			// �������
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-03", "Compaq");

			// cpu����
			try {
				Vector cpunum = rpctarget.getKPISet("/usr/sbin/sizer -p");
				String num = (String) cpunum.elementAt(0);
				collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
						+ "-total", "CM-00-01-001-04", num.trim());
			} catch (Exception e) {
				e.printStackTrace();
			}

			try {
				Vector cpu_type = rpctarget.getKPISet("/usr/sbin/sizer -c");
				String c_type = (String) cpu_type.elementAt(0);

				// cpu����
				collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
						+ "-total", "CM-00-01-001-05", collResult.split(c_type,
						1).replaceAll("\"", ""));
			} catch (Exception e) {
				e.printStackTrace();
			}

			String versionvalue = "";
			try {
				Vector version = rpctarget.getKPISet("/usr/sbin/sizer -v");
				versionvalue = (String) version.elementAt(0);
				// ���汾
				collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
						+ "-total", "CM-00-01-001-08", collResult.split(
						versionvalue, 3));
			} catch (Exception e) {
				e.printStackTrace();
			}

			// ----��ȡ�������Ϣ
			// id ʹ�� -16 ����
			String net_PRE_UNITID = this.PRE_UNITID + "-16";
			String loopback_name = "grep";
			// �õ�����������
			Vector loopback = rpctarget
					.getKPISet("/usr/sbin/netstat -in | grep  127.0.0.1");
			if (loopback != null && loopback.size() > 0) {
				loopback_name = split((String) loopback.elementAt(0), 0);
			}

			// �ɼ��DZ������ �����ַ��ip��ַ, ����
			Vector lancard = rpctarget
					.getKPISet("/usr/sbin/netstat -in |  grep -v Mtu |  grep -v 127.0.0.1 | grep -v "
							+ loopback_name + " | grep -v \"*\"");

			Set lancardSet = new HashSet();
			String service_ip = "";

			for (int i = 0; i < lancard.size(); i++) {
				String lan_name = split((String) lancard.elementAt(i), 0);

				String network = split((String) lancard.elementAt(i), 2); // �����Link����Ϊ�����ַ������Ϊ���ص�ַ

				if (network.indexOf("Link") > -1) {
					// �����ַ
					value = split((String) lancard.elementAt(i), 3);
					collResult.addKPI(net_PRE_UNITID + ":" + neat_host_name
							+ "-" + lan_name, "CM-00-01-001-12", value);
				} else {
					value = split((String) lancard.elementAt(i), 3);
					// ip��ַ��ͬһ����ܳ��ֶ��ip��ַ�����
					collResult.addKPI(net_PRE_UNITID + ":" + neat_host_name
							+ "-" + lan_name, "CM-00-01-001-11", value);
					if (!(value.equals("none"))) {
						service_ip = service_ip + "," + value;
					}
				}

				lancardSet.add(lan_name.trim());
			}

			// �����񣩵�ַ CM-00-01-001-02�� ������ip��ַ�ۼ�
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-02", service_ip.substring(1,
					service_ip.length()));

			// KPI: CM-00-01-001-10 ϵͳ����ӿ���
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-10", Formater
					.formatDecimalKpivalue(String.valueOf(lancardSet.size())));

			// //////////////////////////////////////////////////////////////////////////////

			// �ļ�ϵͳ
			// id ʹ�� -14
			String fs_PRE_UNITID = this.PRE_UNITID + "-14";
			// 16 CM-00-01-001-16 �ļ�ϵͳ��� �ļ�ϵͳ�ı�ʶ 1�� �ַ���
			// 17 CM-00-01-001-17 �ļ�ϵͳ���ܿռ� ����ļ�ϵͳ�ܵĿ��� 1�� ��ֵ��
			// �ļ�ϵͳ��� ���� �����ļ�ϵͳ�ܿռ�
			Vector fileSystem = rpctarget
					.getKPISet("df -ik | grep -v Filesystem");
			long fs_sum = 0; // �ļ�ϵͳ�ܿռ䣬��
			for (int i = 0; i < fileSystem.size(); i++) {
				try {
					String fs_info = (String) fileSystem.elementAt(i);
					String fs_name = collResult.split(fs_info, 8);

					collResult.addKPI(fs_PRE_UNITID + ":" + neat_host_name
							+ "-" + Formater.neatenunitid(fs_name),
							"CM-00-01-001-16", fs_name);

					String fs_size = collResult.split(fs_info, 1);
					fs_size = (fs_size == null || fs_size.trim().length() == 0 || fs_size
							.trim().equals("-")) ? "0" : fs_size.trim();
					long lfs_size = Long.parseLong(fs_size);
					fs_sum = fs_sum + lfs_size;

				} catch (Exception e) {
					e.printStackTrace();
				}
			}// end for

			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-17", Formater
					.formatDecimalKpivalue(String.valueOf(fs_sum / 1024)));

			logger.info("end getConfig");

			return collResult.getKPISet();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;

	}// end getConfig

	// ///////////////////////////////////////////////////////////////////////////////////////////

	/**
	 * 
	 * �ɼ�cpu��kpiȫ[���kpiָ��]
	 * 
	 * ok
	 * 
	 * @param params
	 * @return
	 */
	public Vector getCpu(HashMap params) {
		logger.info("begin getCpu");
		init(params);

		System.out.println("begin getCPU");
		// ����ɼ��������ֵ
		CollBase collResult = new CollBase();

		// �������õ���kpiֵ��unit_id,����PRE_UNITID + "-11"��ͷ�����cpu���
		String cpu_PRE_UNITID = PRE_UNITID + "-11"; // totalֵ

		System.out.println("col host name");
		// ��ȡ������
		String host_name = this.getHostName();
		// �õ�unit_id��ʹ�õ�������
		String neat_host_name = Formater.neatenunitid(host_name);

		// ��Ӳɼ�ʱ��ָ��
		String pattern = "yyyy-MM-dd-HH-mm-ss";
		SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
		collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
				"CM-00-01-001-22", dateFormat.format(new java.util.Date()));

		String value = ""; // ��ʱ��

		Vector cpuout = rpctarget.getKPISet("/usr/bin/vmstat 2 5");
		String cpurun = (String) cpuout.elementAt(cpuout.size() - 1);

		try {
			// CPUʱ�䣺���аٷֱ�
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-01", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 17)));

			// CPUʱ�䣺ϵͳ�ٷֱ�
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-02", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 16)));

			// CPUʱ�䣺�û��ٷֱ�
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-03", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 15)));

			// cpu������
			value = this.getCPU_Rate(3, 30);
			collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
					"PM-00-01-001-05", value);

			// CPU���ж����н�̸���
			Vector vmstat_result = rpctarget.getKPISet("vmstat 2 2");
			String vmstat_string = (String) vmstat_result
					.elementAt(vmstat_result.size() - 1);
			value = collResult.split(vmstat_string, 0);
			collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
					"PM-00-01-001-06", Formater.formatDecimalKpivalue(value));

		} catch (Exception e) {
			e.printStackTrace();
		}

		logger.info("end getCpu");
		return collResult.getKPISet();
	}

	/**
	 * ok
	 * 
	 * PM-00-01-004-01 �ļ�ϵͳʹ�ñ��� �ļ�ϵͳ��ʹ�õĿռ����ܿռ�ı�ֵ PM-00-01-004-02 ������ʹ�ðٷֱ�
	 * ������ʹ�ðٷֱ� PM-00-01-004-03 �߼���(���豸)�ļ�ϵͳʹ���� ���߼������ļ�ϵͳ��ʹ����
	 * 
	 * 
	 * PM-00-01-004-01/03 Object=Disk PM-00-01-004-02 Object=System
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public Vector getFileSystem(HashMap params) {
		logger.info("begin getFileSystem");
		init(params);

		// ����ɼ��������ֵ
		CollBase collResult = new CollBase();

		// ��ȡ������
		String host_name = this.getHostName();
		// �õ�unit_id��ʹ�õ�������
		String neat_host_name = Formater.neatenunitid(host_name);

		// ��Ӳɼ�ʱ��ָ��
		String pattern = "yyyy-MM-dd-HH-mm-ss";
		SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
		collResult.addKPI(PRE_UNITID + "-14" + ":" + neat_host_name + "",
				"CM-00-01-001-22", dateFormat.format(new java.util.Date()));

		// �ɼ����ļ�ϵͳռ����
		long fs_sum = 0; // �ļ�ϵͳ�ܿռ�
		long fs_sum_free = 0; // �ļ�ϵͳ���ѿ���ռ�
		long fs_sum_used = 0;

		Vector filesystemV = rpctarget.getKPISet("df -ik");
		if (filesystemV.size() > 0) {
			for (int i = 1; i < filesystemV.size(); i++) {
				String fsInfo = (String) filesystemV.elementAt(i);
				String fs_name = split(fsInfo, 8);

				String fs_size = split(fsInfo, 1);

				String fs_use = split(fsInfo, 2);

				fs_sum = fs_sum + Long.parseLong(fs_size);

				fs_sum_used = fs_sum_used + Long.parseLong(fs_use);

				fs_sum_free = fs_sum_free + (fs_sum - fs_sum_used);

				String neat_fs_name = Formater.neatenunitid(fs_name);

				String usedPercent = String.valueOf(Long.parseLong(fs_use)
						/ Long.parseLong(fs_size));

				String fs_free = String.valueOf(Long.parseLong(fs_size)
						- Long.parseLong(fs_use));

				try {
					collResult.addKPI(PRE_UNITID + "-14:" + neat_host_name
							+ "-" + neat_fs_name, "PM-00-01-004-03", Formater
							.formatDecimalKpivalue(usedPercent));

					// �ļ�ϵͳ���ÿռ�
					String tmp = fs_free;
					float tmp_free = Float.parseFloat(tmp.trim()) / 1024;

					// String tmp_free = Long.toString(fs_sum_free/1024);
					collResult.addKPI(PRE_UNITID + "-14:" + neat_host_name
							+ "-" + neat_fs_name, "PM-00-01-004-04", Formater
							.formatDecimalKpivalue(Float.toString(tmp_free)));
				} catch (Exception e) {
					e.printStackTrace();
				}

			}
		}

		// ��ȡ�ļ�ϵͳʹ�������
		// PM-00-01-004-01 �ļ�ϵͳ��ռ������Ҫ����
		if (fs_sum != 0) {
			collResult.addKPI(PRE_UNITID + "-10:" + neat_host_name + "-total",
					"PM-00-01-004-01", Formater.formatDecimalKpivalue(String
							.valueOf(100 - fs_sum_free * 100.0 / fs_sum)));
		}

		logger.info("end getFileSystem");
		return collResult.getKPISet();

	}

	/**
	 * ��ȡ�����û������
	 * 
	 * @param params
	 * @return
	 */
	public Vector getUserProNum(HashMap params) {
		logger.info("begin getUserProNum ");
		init(params);

		// �õ������û����б?���û�����ֶ��ٴΣ��ͱ���ps��4�ж����У����ж��ٽ��
		Vector userV = rpctarget.getKPISet("ps -ef -o user | grep -v USER");

		if (userV == null || userV.size() == 0) {
			return new Vector();
		}

		// �������û��Ľ������������map��
		// user - user process numer
		Map user_pronum = new HashMap();
		// ���û�����Ȼ��������
		java.util.Collections.sort(userV);
		for (int i = 0; i < userV.size(); i++) {
			String userName = ((String) userV.elementAt(i)).trim();
			int pro_number = 1;
			for (int j = i + 1; j < userV.size(); j++) {

				// ������һ���û�
				String nextUer = ((String) (userV.elementAt(j))).trim();
				if (!userName.equals(nextUer)) {
					i = j - 1;
					break;
				}
				pro_number++;
			}
			user_pronum.put(userName, new Integer(pro_number));
		}// end for

		// ����ɼ��������ֵ
		CollBase collResult = new CollBase();

		// �������õ���kpiֵ��unit_id,����PRE_UNITID + "-10"��ͷ�����Total���
		String pro_PRE_UNITID = PRE_UNITID + "-15"; // totalֵ

		// ��ȡ������
		String host_name = this.getHostName();
		// �õ�unit_id��ʹ�õ�������
		String neat_host_name = Formater.neatenunitid(host_name);

		Set users = user_pronum.keySet();
		Iterator iter = users.iterator();
		while (iter.hasNext()) {
			String username = (String) iter.next();
			collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
					+ Formater.neatenunitid(username), "PM-00-01-005-06",
					((Integer) user_pronum.get(username)).toString());
			collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
					+ Formater.neatenunitid(username), "CM-00-01-005-06",
					Formater.neatenunitid(username));
		}
		return collResult.getKPISet();
	}

	public void init(HashMap params) {
		rpctarget = new RPCTarget();
	}

	private String getHostName() {
		Vector host = rpctarget.getKPISet("uname -a");
		String host_name = (String) host.elementAt(0);
		host_name = split(host_name, 1);
		return host_name;

	}

	// �ɼ�cpu������,���ɼ�times��,ÿ�βɼ����interval��
	private String getCPU_Rate(int times, int interval) {
		CollBase collResult = new CollBase();
		float cpu_value = 0;
		for (int i = 0; i < times; i++) {

			Vector cpuout = rpctarget.getKPISet("vmstat 1 3");
			String cpurun = (String) cpuout.elementAt(cpuout.size() - 1);

			cpu_value = (100 - Integer.parseInt(collResult.split(cpurun, 17)))
					+ cpu_value;

			try {
				Thread.sleep(interval * 1000L);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		logger.info("cpu_value1=" + cpu_value);
		cpu_value = cpu_value / times;
		logger.info("cpu_value2=" + cpu_value);
		return Formater.formatDecimalKpivalue(Float.toString(cpu_value));
	}

	/*
	 * public void release() { if (rpctarget != null)
	 * rpctarget.releaseResources(); }
	 */

	/**
	 * �����˷���,���� �մ�
	 */
	private String split(String str, int pos) {
		StringTokenizer st = new StringTokenizer(str);
		Vector values = new Vector();
		while (st.hasMoreTokens()) {
			values.add(st.nextToken());
		}
		if (pos >= 0 && pos < values.size()) {
			return (String) values.elementAt(pos);
		}
		return "";
	}

	/**
	 * 
	 * �õ�ָ�����ȵ�double������ֵ �����趨Ϊ4
	 * 
	 * @param double_vlaue
	 * @return
	 */
	// private String getByScale(String double_value) {
	// int scale = 2;
	// return Formater.getByScale(double_value, scale);
	// }
	public static void main(String[] args) {

	}// end main

}