package com.sitech.ismp.coll.loadBalance;

import com.sitech.ismp.coll.CollBase;
import com.sitech.ismp.coll.net.f5.InterfaceEntry;
import com.sitech.ismp.coll.net.f5.InterfaceEntryWalker;
import com.sitech.ismp.coll.net.f5.MultiHostCpuEntry;
import com.sitech.ismp.coll.net.f5.MultiHostCpuEntryWalker;
import com.sitech.ismp.coll.net.f5.VirtualServEntry;
import com.sitech.ismp.coll.net.f5.VirtualServEntryWalker;
import com.sitech.ismp.coll.net.f5.PoolMemberEntry;
import com.sitech.ismp.coll.net.f5.PoolMemberEntryWalker;
import com.sitech.util.DES3;
import com.sitech.util.Formater;
import com.sitech.util.SNMPClient;
import org.apache.log4j.Logger;
import org.snmp4j.mp.SnmpConstants;

import java.util.HashMap;
import java.util.Vector;

/**
 * Created by mooker on 15/8/3.
 */
public class CollF5lbWithSNMP {

    private Logger logger = Logger.getLogger("COLL");
    private String PRE_UNITID = "10-19-10";

    private String ipAddr;
    private String deviceName;
    private int snmpPort;
    private int snmpVersion;
    private String snmpCommunity;
    private boolean isConn = false;
    private boolean isSupportSnmp = false;

    private String serurityName;
    private String authenticationPassphrase;
    private String privacyPassphrase;
    private String authProtocal;
    private String  privProtocal;
    private String securityLevel;

    private SNMPClient client;

    private String sysObjectID;

    private void init(HashMap<String, String> params) throws Exception {
        ipAddr = params.get("IPADDR");
        deviceName = Formater.neatenunitid(params.get("IPADDR"));
//        deviceName = Formater.neatenunitid(params.get("DEVICEID"));

        try {
            snmpCommunity = DES3.decrypt(params.get("COMMUNITY"));
        } catch (Exception e) {
            throw new Exception("Wrong SNMP COMMUNITY:" + DES3.decrypt(params.get("COMMUNITY")));
        }

        try {
            snmpPort = Integer.parseInt(params.get("SNMPPORT"));
        } catch (Exception e) {
            throw new Exception("Wrong SNMP PORT:" + params.get("SNMPPORT"));
        }

        String versionStr = params.get("SNMPVERSION");

        if (versionStr != null && versionStr.toLowerCase().trim().equals("v1")) {
            snmpVersion = SnmpConstants.version1;
        } else if (versionStr != null
                && versionStr.toLowerCase().trim().equals("v2c")) {
            snmpVersion = SnmpConstants.version2c;
        } else if (versionStr != null
                && versionStr.toLowerCase().trim().equals("v3")) {
            snmpVersion = SnmpConstants.version3;
        } else {
            // 默认按照v2c版本采集
            snmpVersion = SnmpConstants.version2c;
        }
        if (SnmpConstants.version3 == snmpVersion) {
            serurityName = params.get("securityName");
            if (params.get("authenticationPassphrase") != null) {
                authenticationPassphrase = DES3.decrypt(params.get("authenticationPassphrase"));
            }
            authProtocal = params.get("authenticationProtocol");
            privProtocal = params.get("privacyProtocol");
            if (params.get("privacyPassphrase") != null) {
                privacyPassphrase = DES3.decrypt(params.get("privacyPassphrase"));
            }
            securityLevel = params.get("auth_priv_mode");
        }
    }

    private void connect() throws Exception {
        client = new SNMPClient(ipAddr, snmpPort, snmpCommunity, snmpVersion, securityLevel,
                serurityName, authProtocal, authenticationPassphrase, privProtocal, privacyPassphrase);
        isSupportSnmp = client.isOpenSNMP();
        isConn = client.connect();
        if (!isConn || !isSupportSnmp) {
            throw new Exception("Device not support SNMP or Collect params is wrong " +
                    " or Network is error: " + ipAddr + ":" + snmpPort);
        }
        sysObjectID = client.get("1.3.6.1.2.1.1.2.0");
        logger.info("sysObjectID is: " + sysObjectID);
    }

    public void destroy() {
        if(client != null){
            client.close();
        }
    }

    public Vector getConfig(HashMap<String, String> params) {
        logger.info("begin getConfig");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            connect();
            String UNIT_ID = PRE_UNITID + "-10" + ":" + deviceName + "-total";

            // CM-00-02-001-04 设备名称
            collResult.addKPI(UNIT_ID, "CM-00-02-001-04", getSystemName());

            // CM-01-04-001-02 设备IP地址
            collResult.addKPI(UNIT_ID, "CM-01-04-001-02", this.ipAddr);

            // CM-00-01-001-22 系统启动时间
            collResult.addKPI(UNIT_ID, "CM-00-01-001-22", getDevSysUpTime());

            // CM-00-02-001-03 设备软件版本
            collResult.addKPI(UNIT_ID, "CM-00-02-001-03", getSoftVersion());
        } catch (Exception e) {
            logger.error("getConfig has error", e);
        } finally {
            destroy();
        }
        logger.info("end getConfig");
        return collResult.getKPISet();
    }

    public Vector getIntefaces(HashMap<String, String> params) {
        logger.info("begin getIntefaces");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            InterfaceEntryWalker ifTable = new InterfaceEntryWalker();
            ifTable.FillTable(params.get("IPADDR"), Integer.parseInt(params.get("SNMPPORT")), DES3.decrypt(params.get("COMMUNITY")));
            Vector ifStatRows = ifTable.getEntry();
//                IfTable ifTable = new IfTable();
//                ifTable.FillTable(params.get("IPADDR"), Integer.parseInt(params.get("SNMPPORT")), DES3.decrypt(params.get("COMMUNITY")));
//                Vector ifStatRows = ifTable.getRrows();
            for (int i = 0; i < ifStatRows.size(); i++) {
                InterfaceEntry row = (InterfaceEntry) ifStatRows.get(i);
                String ifName = row.getName();
                String UNIT_ID = PRE_UNITID + "-11" + ":" + deviceName + "-" + Formater.neatenunitid(ifName) + "-interface";
                // CM-00-02-002-01 端口名称
                collResult.addKPI(UNIT_ID, "CM-00-02-002-01", ifName);
                // PM-00-01-900-01 端口流量
                Double bytesIO = (Double.valueOf(row.getBytesIn()) + Double.valueOf(row.getBytesOut())) / 1024.0 / 1024.0;
                collResult.addKPI(UNIT_ID, "PM-00-01-900-01", Formater.formatDecimalByScale(String.valueOf(bytesIO), 2));
                // PM-00-04-099-05 端口状态
                collResult.addKPI(UNIT_ID, "PM-00-04-099-05", this.parsePauseActive(row.getPauseActive()));
            }
        } catch (Exception e) {
            logger.error("getIntefaces has error", e);
        } finally {
            destroy();
        }
        logger.info("end getIntefaces");
        return collResult.getKPISet();
    }

    public Vector getCpuMemConns(HashMap<String, String> params) {
        logger.info("begin getCpuMemConns");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            connect();

            MultiHostCpuEntryWalker mhceTable = new MultiHostCpuEntryWalker();
            mhceTable.FillTable(params.get("IPADDR"), Integer.parseInt(params.get("SNMPPORT")), DES3.decrypt(params.get("COMMUNITY")));
            Vector mhceRows = mhceTable.getEntry();
            String UNIT_ID = PRE_UNITID + "-10" + ":" + deviceName + "-total";
            int cpuRate = 0;
            for (int i = 0; i < mhceRows.size(); i++) {
                MultiHostCpuEntry row = (MultiHostCpuEntry) mhceRows.get(i);
                cpuRate += Integer.parseInt(row.getCpuUsageRatio());
            }
            // PM-00-01-001-05 CPU利用率
            collResult.addKPI(UNIT_ID, "PM-00-01-001-05", String.valueOf(cpuRate / mhceRows.size()));

            String usedMem = this.getSysHostMemoryUsed();
            String totalMem = this.getSysHostMemoryTotal();
            Double dou = Double.valueOf(usedMem) / Double.valueOf(totalMem) * 100;
            // PM-00-01-002-01 内存使用率
            collResult.addKPI(UNIT_ID, "PM-00-01-002-01", Formater.formatDecimalByScale(String.valueOf(dou), 2));

            // PM-23-00-001-04 客户端连接数
            collResult.addKPI(UNIT_ID, "PM-23-00-001-04", this.getSysStatClientCurConns());
        } catch (Exception e) {
            logger.error("getCpuMemConns has error", e);
        } finally {
            destroy();
        }
        logger.info("end getCpuMemConns");
        return collResult.getKPISet();
    }

    public Vector getCapacity(HashMap<String, String> params) {
        logger.info("begin getCapacity");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            connect();
            String UNIT_ID = PRE_UNITID + "-10" + ":" + deviceName + "-total";
//            String cliIn1 = this.getSysStatBytesInOut().get("CLIIN");
//            String cliOut1 = this.getSysStatBytesInOut().get("CLIIN");
//            String serIn1 = this.getSysStatBytesInOut().get("CLIIN");
//            String serOut1 = this.getSysStatBytesInOut().get("CLIIN");
//            Thread.sleep(5);
//            String cliIn2 = this.getSysStatBytesInOut().get("CLIIN");
//            String cliOut2 = this.getSysStatBytesInOut().get("CLIIN");
//            String serIn2 = this.getSysStatBytesInOut().get("CLIIN");
//            String serOut2 = this.getSysStatBytesInOut().get("CLIIN");
            String bytesInOut1 = this.getBytesInOut();
            Thread.sleep(10 * 1000L);
            String bytesInOut2 = this.getBytesInOut();
            Double dou = (Double.valueOf(bytesInOut2) - Double.valueOf(bytesInOut1)) / 10;
            // PM-00-05-009-31 吞吐率
            collResult.addKPI(UNIT_ID, "PM-00-05-009-31", Formater.formatDecimalByScale(String.valueOf(dou), 2));
        } catch (Exception e) {
            logger.error("getCapacity has error", e);
        } finally {
            destroy();
        }
        logger.info("end getCapacity");
        return collResult.getKPISet();
    }

    public Vector getVirtualServer(HashMap<String, String> params) {
        logger.info("begin getVirtualServer");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            VirtualServEntryWalker vsewTable = new VirtualServEntryWalker();
            vsewTable.FillTable(params.get("IPADDR"), Integer.parseInt(params.get("SNMPPORT")), DES3.decrypt(params.get("COMMUNITY")));
            Vector vseRows = vsewTable.getEntry();
            for (int i = 0; i < vseRows.size(); i++) {
                VirtualServEntry row = (VirtualServEntry) vseRows.get(i);
                String vsName = row.getName();
                String UNIT_ID = PRE_UNITID + "-12" + ":" + deviceName + "-" + Formater.neatenunitid(vsName);
                // CM-00-02-002-10 VS的名称
                collResult.addKPI(UNIT_ID, "CM-00-02-002-10", vsName);
                // CM-00-02-002-11 VS的IP地址
                collResult.addKPI(UNIT_ID, "CM-00-02-002-11", Formater.hexToInt(row.getAddr()));
                // CM-00-02-002-12 VS的默认pool
                collResult.addKPI(UNIT_ID, "CM-00-02-002-12", row.getDefaultPool());
            }
        } catch (Exception e) {
            logger.error("getVirtualServer has error", e);
        } finally {
            destroy();
        }
        logger.info("end getVirtualServer");
        return collResult.getKPISet();
    }

    public Vector getPool(HashMap<String, String> params) {
        logger.info("begin getPool");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            PoolMemberEntryWalker pmeTable = new PoolMemberEntryWalker();
            pmeTable.FillTable(params.get("IPADDR"), Integer.parseInt(params.get("SNMPPORT")), DES3.decrypt(params.get("COMMUNITY")));
            Vector pmeRows = pmeTable.getEntry();
            for (int i = 0; i < pmeRows.size(); i++) {
                PoolMemberEntry row = (PoolMemberEntry) pmeRows.get(i);
                String poolName = row.getPoolName();
                String memAddrs = Formater.hexToInt(row.getAddr());
                String UNIT_ID = PRE_UNITID + "-13" + ":" + deviceName + "-" + Formater.neatenunitid(poolName) + "_" + Formater.neatenunitid(memAddrs);
                // CM-00-02-002-13 Pool名称
                collResult.addKPI(UNIT_ID, "CM-00-02-002-13", poolName);
                // CM-00-02-002-14 PoolMember的IP地址
                collResult.addKPI(UNIT_ID, "CM-00-02-002-14", memAddrs);
            }
        } catch (Exception e) {
            logger.error("getPool has error", e);
        } finally {
            destroy();
        }
        logger.info("end getPool");
        return collResult.getKPISet();
    }

    /**
     * 采集系统启动时间
     */
    private String getDevSysUpTime() {
        String oid = "1.3.6.1.2.1.1.3.0";
        String sysUpTime = null;
        try {
            sysUpTime = client.get(oid);
        } catch (Exception e) {
            logger.error("Exception while getDevSysUpTime", e);
        }
        return sysUpTime;
    }

    /**
     * 设备软件版本
     */
    private String getSoftVersion() {
        String oid = "1.3.6.1.2.1.1.1.0";
        String version = null;
        try {
            version = client.get(oid).replace("\n", " ").replace("\r", "");
        } catch (Exception e) {
            logger.error("Exception while getSoftVersion", e);
        }
        return version;
    }

    private String getSystemName() {
        String oid = "1.3.6.1.2.1.1.5.0";
        String systemName = null;
        try {
            systemName = client.get(oid);
        } catch (Exception e) {
            logger.error("Exception while getSystemName", e);
        }
        return systemName;
    }

    /**
     * 内存总大小
     */
    private String getSysHostMemoryTotal() {
        String oid = "1.3.6.1.4.1.3375.2.1.7.1.1.0";
        String memTotal = null;
        try {
            memTotal = client.get(oid);
        } catch (Exception e) {
            logger.error("Exception while getSysHostMemoryTotal", e);
        }
        return memTotal;
    }

    /**
     * 内存已使用大小
     */
    private String getSysHostMemoryUsed() {
        String oid = "1.3.6.1.4.1.3375.2.1.7.1.2.0";
        String memUsed = "";
        try {
            memUsed = client.get(oid);
        } catch (Exception e) {
            logger.error("Exception while getSysHostMemoryUsed", e);
        }
        return memUsed;
    }

    private String getSysStatClientCurConns() {
        String oid = "1.3.6.1.4.1.3375.2.1.1.2.1.8.0";
        String clientConns = "";
        try {
            clientConns = client.get(oid);
        } catch (Exception e)  {
            logger.error("Exception while getSysStatClientCurConns", e);
        }
        return clientConns;
    }

    public HashMap<String, String> getSysStatBytesInOut() {
        HashMap<String, String> map = new HashMap<String, String>();
        String cliInoid = "1.3.6.1.4.1.3375.2.1.1.2.1.3";
        String cliOutoid = "1.3.6.1.4.1.3375.2.1.1.2.1.5";
        String serInoid = "1.3.6.1.4.1.3375.2.1.1.2.1.10";
        String serOutoid = "1.3.6.1.4.1.3375.2.1.1.2.1.12";
        try {
            map.put("CLIIN", client.get(cliInoid));
            map.put("CLIOUT", client.get(cliOutoid));
            map.put("SERIN", client.get(serInoid));
            map.put("SEROUT", client.get(serOutoid));
        } catch (Exception e) {
            logger.error("Exception while getSysStatClientBytesIn", e);
        }
        return map;
    }

    public String getBytesInOut() {
        Double dou = 0.0;
        String cliInoid = "1.3.6.1.4.1.3375.2.1.1.2.1.3.0";
        String cliOutoid = "1.3.6.1.4.1.3375.2.1.1.2.1.5.0";
        String serInoid = "1.3.6.1.4.1.3375.2.1.1.2.1.10.0";
        String serOutoid = "1.3.6.1.4.1.3375.2.1.1.2.1.12.0";
        try {
            System.out.println(client.get(cliInoid) + " " + client.get(cliOutoid) + " " + client.get(serInoid) + " " + client.get(serOutoid));
            dou = (Double.valueOf(client.get(cliInoid)) +
                    Double.valueOf(client.get(cliOutoid)) +
                    Double.valueOf(client.get(serInoid)) +
                    Double.valueOf(client.get(serOutoid))) / 1024.0 / 1024.0;
        } catch (Exception e) {
            logger.error("Exception while getSysStatClientBytesIn", e);
        }
        return String.valueOf(dou);
    }

    /**
     * 端口状态映射
     * none(0) - no pause,
     * txrx(1) - pause all data flow,
     * tx(2) - pause out going data flow,
     * rx(3) - pause in coming data flow
     */
    public String parsePauseActive(String pauseActive) {
        String res = "none";
        if ("0".equals(pauseActive)) {
            res = "no pause";
        } else if ("1".equals(pauseActive)) {
            res = "pause all";
        } else if ("2".equals(pauseActive)) {
            res = "pause out";
        } else if ("3".equals(pauseActive)) {
            res = "pause in";
        }
        return res;
    }
}