package com.sitech.ismp.coll.database;

import com.mongodb.MongoClient;
import com.sitech.ismp.coll.CollBase;
import com.sitech.util.Formater;
import org.apache.log4j.Logger;
import org.bson.BsonDocument;
import org.bson.Document;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Vector;

/**
 * Created with IntelliJ IDEA.
 * User: ZhouYou
 * Date: 15-6-10
 * Time: 下午1:58
 * To change this template use File | Settings | File Templates.
 */
public class CollMongoDbWithCMD extends CollBase {

//    private Logger logger = Logger.getLogger(CollMongoDbWithCMD.class);

    private static Logger logger = Logger.getLogger("COLL");
    String KBP_CLASS = "10-11-37";

    private String hostIP;
    private String hostName;
    private String mongoDbPort;
    private String dbName;
    private String order1;
    private String order2;
    private String order3;

//        String order1 = "dbStats";
//        String order2 = "serverStatus";
//        String order3 = "replSetGetStatus";
    MongoClient mongoClient = null;
    private List<String> masterList = new ArrayList<String>();

    public void init(HashMap params) {
        hostIP = (String) params.get("HOSTIP");
        mongoDbPort = (String) params.get("MONGODBPORT");
        dbName = (String) params.get("DBNAME");
//        hostName = (String) params.get("DEVICENAME");
        this.hostName = Formater.neatenunitid(dbName);
//        order1 = (String) params.get("order1");
//        order2 = (String) params.get("order2");
//        order3 = (String) params.get("order3");
        logger.info("-->hostIP:" + hostIP);
        logger.info("-->mongoDbPort:" + mongoDbPort);
        logger.info("-->dbName:" + dbName);
        logger.info("-->hostName:" + hostName);
//        logger.info("-->order1:" + order1);
//        logger.info("-->order2:" + order2);
//        logger.info("-->order3:" + order3);
        try {
            mongoClient = new MongoClient(hostIP, Integer.valueOf(mongoDbPort));
        } catch (Exception e) {
            logger.error("MongoDb连接出错:", e);
        }
    }

    /**
     * 采集数据库基本信息指标
     *
     * @param params
     * @return
     */
    public Vector getSystem(HashMap params) {
        logger.info(">>>数据库基本信息指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));
            String version = doc.get("version").toString();
            logger.info("采集的mongodb版本：" + version + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-10" + ":" + hostName + "-system", "CM-00-03-001-02", version);
            String runTime = doc.get("uptime").toString();
            logger.info("采集的mongodb运行时间：" + runTime + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-10" + ":" + hostName + "-system", "CM-00-01-999-03", runTime);
        } catch (Exception e) {
            logger.error("采集MongoDb基本信息指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库运行连接指标
     *
     * @param params
     * @return
     */
    public Vector getConnection(HashMap params) {
        logger.info(">>>数据库运行连接指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{serverStatus : 1}"));

            String progressName = doc.get("process").toString();
            logger.info("采集的mongodb进程名称：" + progressName + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-11" + ":" + hostName + "-connection", "CM-00-01-005-07", progressName);

            String progressPID = doc.get("pid").toString();
            logger.info("采集的mongodb进程PID：" + progressPID + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-11" + ":" + hostName + "-connection", "CM-00-01-005-01", progressPID);

            String currentConnectNum = (((Document) doc.get("connections")).get("current")).toString();
            logger.info("采集的mongodb当前连接数：" + currentConnectNum + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-11" + ":" + hostName + "-connection", "PM-11-37-001-01", currentConnectNum);

            String availableConnectNum = (((Document) doc.get("connections")).get("available")).toString();
            logger.info("采集的mongodb可用连接数：" + availableConnectNum + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-11" + ":" + hostName + "-connection", "PM-11-37-001-02", availableConnectNum);

            String totalCreatedConnectNum = (((Document) doc.get("connections")).get("totalCreated")).toString();
            logger.info("采集的mongodb已创建的总连接数：" + totalCreatedConnectNum + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-11" + ":" + hostName + "-connection", "PM-11-37-001-03", totalCreatedConnectNum);
        } catch (Exception e) {
            logger.error("采集MongoDb运行连接指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库运行状态指标
     *
     * @param params
     * @return
     */
    public Vector getRunningState(HashMap params) {
        logger.info(">>>数据库运行状态指标集采集");
        CollBase collResult = new CollBase();
        String runStateOk = "运行正常";
        String runStateErr = "运行不正常";
        try {
            init(params);
            //  mongoClient = new MongoClient(hostIP, Integer.valueOf(mongoDbPort));
            logger.info("采集的mongodb运行状态：" + runStateOk + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-12" + ":" + hostName + "-runningStatus",
                    "FM-00-03-001-01", runStateOk);
        } catch (Exception e) {
            logger.info("采集的mongodb运行状态：" + runStateErr + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-12" + ":" + hostName + "-runningStatus",
                    "FM-00-03-001-01", runStateErr);
            logger.error("采集MongoDb运行状态指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库网络指标
     *
     * @param params
     * @return
     */
    public Vector getNet(HashMap params) {
        logger.info(">>>数据库网络指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));

            String bytesOut = (((Document) doc.get("network")).get("bytesOut")).toString();
            logger.info("采集的mongodb流出流量：" + bytesOut + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-13" + ":" + hostName + "-net",
                    "PM-11-37-001-04", bytesOut);

            String bytesIn = (((Document) doc.get("network")).get("bytesIn")).toString();
            logger.info("采集的mongodb流入流量：" + bytesIn + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-13" + ":" + hostName + "-net",
                    "PM-11-37-001-05", bytesIn);

            String numRequests = (((Document) doc.get("network")).get("numRequests")).toString();
            logger.info("采集的mongodb 发送到数据库的请求量：" + numRequests + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-13" + ":" + hostName + "-net",
                    "PM-11-37-001-06", numRequests);
        } catch (Exception e) {
            logger.error("采集MongoDb网络指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库操作数指标
     *
     * @param params
     * @return
     */
    public Vector getOperateNum(HashMap params) {
        logger.info(">>>数据库操作数指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));

            String query = (((Document) doc.get("opcounters")).get("query")).toString();
            logger.info("采集的mongodb启动以来查询的次数：" + query + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-07", query);

            String insert = (((Document) doc.get("opcounters")).get("insert")).toString();
            logger.info("采集的mongodb启动以来插入的次数：" + insert + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-08", insert);

            String update = (((Document) doc.get("opcounters")).get("update")).toString();
            logger.info("采集的mongodb更新的次数：" + update + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-09", update);

            String delete = (((Document) doc.get("opcounters")).get("delete")).toString();
            logger.info("采集的mongodb删除数：" + delete + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-10", delete);

            String getmore = (((Document) doc.get("opcounters")).get("getmore")).toString();
            logger.info("采集的mongodb启动以来调用任何游标的getMore总次数：" + getmore + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-11", getmore);

            String command = (((Document) doc.get("opcounters")).get("command")).toString();
            logger.info("采集的mongodb启动以来执行其他命令的总次数：" + command + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-14" + ":" + hostName + "-operateNum",
                    "PM-11-37-001-12", command);
        } catch (Exception e) {
            logger.error("采集MongoDb操作数指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库数据同步磁盘指标
     *
     * @param params
     * @return
     */
    public Vector getDataToDisk(HashMap params) {
        logger.info(">>>数据库数据同步磁盘指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));

            String flushes = (((Document) doc.get("backgroundFlushing")).get("flushes")).toString();
            logger.info("采集的mongodb数据同步磁盘总数：" + flushes + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-15" + ":" + hostName + "-dataToDisk",
                    "PM-11-37-001-13", flushes);

            String total_ms = (((Document) doc.get("backgroundFlushing")).get("total_ms")).toString();
            logger.info("采集的mongodb数据同步到磁盘毫秒数：" + total_ms + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-15" + ":" + hostName + "-dataToDisk",
                    "PM-11-37-001-14", total_ms);

            String average_ms = (((Document) doc.get("backgroundFlushing")).get("average_ms")).toString();
            logger.info("采集的mongodb数据同步到磁盘平均毫秒数：" + average_ms + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-15" + ":" + hostName + "-dataToDisk",
                    "PM-11-37-001-15", average_ms);

            String last_ms = (((Document) doc.get("backgroundFlushing")).get("last_ms")).toString();
            logger.info("采集的mongodb最后数据同步磁盘完成时间：" + last_ms + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-15" + ":" + hostName + "-dataToDisk",
                    "PM-11-37-001-17", last_ms);

            String last_finished = (((Document) doc.get("backgroundFlushing")).get("last_finished")).toString();
            logger.info("采集的mongodb最后数据同步磁盘平均毫秒数：" + last_finished + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-15" + ":" + hostName + "-dataToDisk",
                    "PM-11-37-001-16", last_finished);
        } catch (Exception e) {
            logger.error("采集MongoDb数据同步磁盘指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库内存指标
     *
     * @param params
     * @return
     */
    public Vector getInternalMemory(HashMap params) {
        logger.info(">>>数据库内存指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));

            String bits = (((Document) doc.get("mem")).get("bits")).toString();
            logger.info("采集的mongodb软件位数：" + bits + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "CM-00-03-001-03", bits);

            String resident = (((Document) doc.get("mem")).get("resident")).toString();
            logger.info("采集的mongodb占用的物理内存量：" + resident + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "PM-11-37-001-18", resident);

            String virtual = (((Document) doc.get("mem")).get("virtual")).toString();
            logger.info("采集的mongodb占用的虚拟内存量：" + virtual + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "PM-11-37-001-19", virtual);

            String supported = (((Document) doc.get("mem")).get("supported")).toString();
            logger.info("采集的mongodb是否支持扩展内存：" + supported + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "FM-11-37-001-01", supported);

            String mapped = (((Document) doc.get("mem")).get("mapped")).toString();
            logger.info("采集的mongodb映射到内存的数据文件大小：" + mapped + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "PPM-11-37-001-20", mapped);

            String mappedWithJournal = (((Document) doc.get("mem")).get("mappedWithJournal")).toString();
            logger.info("采集的mongodb mappedWithJournal：" + mappedWithJournal + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-16" + ":" + hostName + "-internalMemory",
                    "PM-11-37-001-21", mappedWithJournal);
        } catch (Exception e) {
            logger.error("采集MongoDb内存指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集数据库当前锁队列指标
     *
     * @param params
     * @return
     */
    public Vector getNowLockedList(HashMap params) {
        logger.info(">>>数据库当前锁队列指标集采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'serverStatus' : 1}"));

            String total = (((Document) ((Document) doc.get("globalLock")).get("currentQueue")).get("total")).toString();
            logger.info("采集的mongodb锁队列操作数：" + total + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-17" + ":" + hostName + "-nowLockedList",
                    "PM-11-37-001-22", total);

            String readers = (((Document) ((Document) doc.get("globalLock")).get("currentQueue")).get("readers")).toString();
            logger.info("采集的mongodb锁队列读操作数：" + readers + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-17" + ":" + hostName + "-nowLockedList",
                    "PM-11-37-001-23", readers);

            String writers = (((Document) ((Document) doc.get("globalLock")).get("currentQueue")).get("writers")).toString();
            logger.info("采集的mongodb锁队列写操作数：" + writers + ",资源标识：" + hostName);
            collResult.addKPI("10-11-37-17" + ":" + hostName + "-nowLockedList",
                    "PM-11-37-001-24", writers);
        } catch (Exception e) {
            logger.error("采集MongoDb当前锁队列指标出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

    /**
     * 采集mongodb集群节点信息指标
     *
     * @param params
     * @return
     */
    public Vector getPoint(HashMap params) {
        logger.info(">>>mongodb集群节点信息采集");
        CollBase collResult = new CollBase();
        init(params);
        try {
            Document doc = mongoClient.getDatabase(dbName).runCommand(BsonDocument.parse("{'replSetGetStatus' : 1}"));
            ArrayList points = (ArrayList) doc.get("members");
            logger.info("-->point大小：" + points.size());
            for (int i = 0; i < points.size(); i++) {
                String pt = (((Document) (points.get(i))).get("name")).toString();
                logger.info("-->pointName：" + pt);
                collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i, "CM-00-03-011-01", pt);
            }
            masterList.clear();
            for (int i = 0; i < points.size(); i++) {
                String master = (((Document) (points.get(i))).get("stateStr")).toString();
                logger.info("-->point_master：" + master);
                if ("PRIMARY".equals(master)) {
                    master = "主";
                    collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i, "CM-00-03-011-02", master);
                    masterList.add(String.valueOf(i));
                } else {
                    master = "备";
                    collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i, "CM-00-03-011-03", master);
                }
                collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i,
                        "CM-00-03-011-04", master);
            }
            for (int i = 0; i < points.size(); i++) {
                String pthl = (((Document) (points.get(i))).get("health")).toString();
                logger.info("-->point_healthr：" + pthl);
                if ("1".equals(pthl)) {
                    pthl = "正常";
                } else {
                    pthl = "不正常";
                }
                boolean flag = false;
                for (int j = 0; j < masterList.size(); j++) {
                    if (i == Integer.valueOf(masterList.get(j))) {
                        flag = true;
                        break;
                    }
                }
                if (flag) {
                    collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i,
                            "FM-00-03-001-10", pthl);
                } else {
                    collResult.addKPI("10-32-13-11" + ":" + hostName + "-point" + i,
                            "FM-00-03-001-11", pthl);
                }
            }
        } catch (Exception e) {
            logger.error("采集mongodb集群节点信息出错:", e);
        } finally {
            logger.info("关闭与MongoDb的连接");
            mongoClient.close();
        }
        return collResult.getKPISet();
    }

}