package com.doumee.core.device;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.*;

public class ElectronicToolUitl {

    // 授权码 登录 后台获取， 联系你的甲方或者是销售
    private static String auth_code = "1f29d378fc6792d5d2b735877993ffb7";
    // 随机字符串 后台获取
    private static String nonce = "lvyOY7fcun719WkxF8ToVYatStgt";
    // 测试用采集器号  请使用真实设备采集器号
    private static String debug_collector = "19020618114";
    // 测试用电表号 请使用真实设备采集器号
    private static String debug_meter = "000066660942";
    // 异步通知地址（服务如果部署在内网，在公网无法直接访问到，需要在路由器上配置端口映射，或者配置内网穿透工具来实现访问） 此处仅为测试 示例
    private static String notify_url = "http://115.221.15.8:8055/notify";
    private static String api_url = "http://api1.tqdianbiao.com";
    private static String api2_url = "http://api2.tqdianbiao.com";


    public static void main(String[] args) {
// 注意 如需使用充值功能 可先了解 [参数维护模式](http://doc-api.tqdianbiao.com/doc/backend/data_sync_mode.html)
// 注意 有2个系统 授权码等参数  各自独立   接口域名分别为  https://iot.tqdianbiao.com/  http://api1.tqdianbiao.com

//        -------- 系统维护关键参数模式 接口-------------
//        采集器添加();
//        采集器删除();
//        查询N个采集器();
//        查询全部采集器();
//
//        电能表添加();
//        电能表删除();
//        电能表档案查询();
//
//        水表添加();
//        水表删除();
//        水表档案查询();

//        操作状态查询();
//        取消操作();


//        ------------ 接入方维护关键参数模式 数据接口-------------
//        抄电表数据();
//        设置电表参数();
//        电表拉闸();
//        电表合闸();
//        电表清零_同步模式();
//        电表清零_非同步模式();
//        电表开户_同步模式();
//        电表开户_非同步模式();
//        电表充值_同步模式();
//        电表充值_非同步模式();

//        抄水表数据();
//        水表关阀();
//        水表开阀();
//        水表清零();
//        Mbus水表充值_同步模式();
//        Mbus水表充值_非同步模式();
//        Lora水表充值_同步模式();
//        Lora水表充值_非同步模式();

        Lora普通预付费水表设置水价();
        Lora阶梯预付费水表设置水价();

//        第一套数据接口--------------
//        查询历史数据接口();
//        查询设备列表和当前状态();
//        查询采集器列表和当前状态();
//        查询价格档案();
//        查询用户档案();
//        查询参数档案();
//        查询电表当前状态数据();
//        查询水表当前状态数据();

    }

    /**
     * 查询设备列表和当前状态
      */
    private static void queryDeviceList() {
        // 查询设备列表和当前状态
        String url = api_url+"/Api/Meter";  // "https://iot.tqdianbiao.com/Api/Meter"
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);
        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);

        url = url + "?" + urlParams;

        String resp = HttpClientGet(url);

        simpleRequestPrint(url, resp);
    }

    /**
     * 查询采集器列表和当前状态
     */
    private static void queryCollectorList() {
        // 查询采集器列表和当前状态
        String url = api_url+"/Api/Collector";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);

        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);

        url = url + "?" + urlParams;

        String resp = HttpClientGet(url);

        simpleRequestPrint(url, resp);
    }

    /**
     * 查询价格档案
     */
    private static void queryPrice() {
        // 查询价格档案
        String url = api_url+"/Api/Price";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);
        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);
        url = url + "?" + urlParams;
        String resp = HttpClientGet(url);
        simpleRequestPrint(url, resp);
    }

    /**
     * 查询用户档案
     */
    private static void queryUser() {
        // 查询用户档案
        String url = api_url+"/Api/User";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);
        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);
        url = url + "?" + urlParams;
        String resp = HttpClientGet(url);
        simpleRequestPrint(url, resp);
    }

    /**
     * 查询参数档案
     */
    private static void queryParam() {
        // 查询参数档案
        String url = api_url+"/Api/Param";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);

        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);

        url = url + "?" + urlParams;

        String resp = HttpClientGet(url);

        simpleRequestPrint(url, resp);
    }

    /**
     * 查询电表当前状态数据
     */
    private static void queryEleMeterState() {
        // 查询电表当前状态数据
        String url = api_url+"/Api/EleMeterState";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);

        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);

        url = url + "?" + urlParams;

        String resp = HttpClientGet(url);

        simpleRequestPrint(url, resp);
    }

    /**
     * 查询水表当前状态数据
     */
    private static void queryWaterMeterState() {
        // 查询水表当前状态数据
        String url = api_url+"/Api/WaterMeterState";
        Map<String, Object> params = new HashMap<>();
        params.put("auth", auth_code);
        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);
        url = url + "?" + urlParams;
        String resp = HttpClientGet(url);
        simpleRequestPrint(url, resp);
    }

    /**
     * 查询历史数据接口
     */
    private static void queryDataRequest() {
        // 查询历史数据接口
        String url = api_url+"/Api/DataRequest";
        Map<String, Object> params = new HashMap<>();
        params.put("auth",          auth_code);
        params.put("type",          "json");
        params.put("functionids",   "3,4,5");
        params.put("start_time",    "2020-01-01 00:00:00");
        params.put("end_time",      "2020-06-01 00:00:00");
        params.put("offset",        0);
        params.put("limit",         100);

        // Map<String, Object> 转成url参数
        String urlParams = getUrlParams(params);
        url = url + "?" + urlParams;
        String resp = HttpClientGet(url);
        simpleRequestPrint(url, resp);

    }

    private static void simpleRequestPrint(String url, String resp) {
        String name=Thread.currentThread().getStackTrace()[2].getMethodName();
        System.out.println(name);

        System.out.println("请求参数：" + url);
        System.out.println("返回数据：" + resp);
    }

    private static String HttpClientGet(String url) {
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpGet httpGet = new HttpGet(url);
            CloseableHttpResponse Response = client.execute(httpGet);
            HttpEntity entity = Response.getEntity();
            String resp = EntityUtils.toString(entity, "UTF-8");
            Response.close();
            return  resp;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return "";
        }
    }

    private static String getUrlParams(Map<String, Object> map) {
        if (map == null || map.size() == 0) {
            return "";
        }
        List<String> list = new ArrayList<>();
        map.forEach((key, value)->{
            try {
                list.add(key + "=" + URLEncoder.encode(value.toString(), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        });
        return String.join("&", list);
    }

    /**
     * 电表开户_同步模式
     */
    private static void openAcount() {
        String url = api2_url+"/Api_v2/ele_security/open_acount";

        // 请求内容，调用接口所需要的数据（电表开户，同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);
    }

    /**
     * 电表开户_非同步模式
     */
    private static void 电表开户_非同步模式() {
        String url = api2_url+"/Api_v2/ele_security/open_acount";

        // 请求内容，调用接口所需要的数据（电表开户，非同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");
        params.put("account_id", "123456");
        params.put("count", "1");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表充值_同步模式() {
        String url = api2_url+"/Api_v2/ele_security/recharge";

        // 请求内容，调用接口所需要的数据（电表充值，同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表充值_非同步模式() {
        String url = api2_url+"/Api_v2/ele_security/recharge";

        // 请求内容，调用接口所需要的数据（电表充值，非同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");
        params.put("account_id", "123456");
        params.put("count", "2");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);
    }

    private static void Lora普通预付费水表设置水价() {
        String url = api2_url+"/Api_v2/water_write/price";

        // 请求内容，调用接口所需要的数据（Lora普通预付费水表设置水价）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("p1", "1");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "10000000031");
        item.put("address", "20040900000003");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void Lora阶梯预付费水表设置水价() {
        String url = api2_url+"/Api_v2/water_write/price";

        // 请求内容，调用接口所需要的数据（Lora阶梯预付费水表设置水价）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("p1", "1");
        params.put("p2", "2");
        params.put("p3", "3");
        params.put("p4", "40");
        params.put("p5", "50");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "10000000031");
        item.put("address", "20040900000003");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void Lora水表充值_同步模式() {
        String url = api2_url+"/Api_v2/water_security/recharge";

        // 请求内容，调用接口所需要的数据（Lora水表充值，同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "10000000031");
        item.put("address", "20040900000003");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void Lora水表充值_非同步模式() {
        String url = api2_url+"/Api_v2/water_security/recharge";

        // 请求内容，调用接口所需要的数据（Lora水表充值，非同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");
        params.put("count", "2");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "10000000031");
        item.put("address", "20040900000003");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void Mbus水表充值_同步模式() {
        String url = api2_url+"/Api_v2/water_security/recharge";

        // 请求内容，调用接口所需要的数据（Mbus水表充值，同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void Mbus水表充值_非同步模式() {
        String url = api2_url+"/Api_v2/water_security/recharge";

        // 请求内容，调用接口所需要的数据（Mbus水表充值，非同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("money", "100");
        params.put("price", "5");
        params.put("count", "2");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 水表清零() {
        String url = api2_url+"/Api_v2/water_security/reset";

        // 请求内容，调用接口所需要的数据（水表清零）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表清零_非同步模式() {
        String url = api2_url+"/Api_v2/ele_security/reset";

        // 请求内容，调用接口所需要的数据（电表清零，非同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("account_id", "123456");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("params", params);

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表清零_同步模式() {
        String url = api2_url+"/Api_v2/ele_security/reset";

        // 请求内容，调用接口所需要的数据（电表清零，同步模式）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");

        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表拉闸() {
        String url = api2_url+"/Api_v2/ele_control";

        // 请求内容，调用接口所需要的数据（电表拉闸）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("type", 10);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 电表合闸() {
        String url = api2_url+"/Api_v2/ele_control";

        // 请求内容，调用接口所需要的数据（电表合闸）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("type", 11);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 水表关阀() {
        String url = api2_url+"/Api_v2/water_control";

        // 请求内容，调用接口所需要的数据（水表关阀）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");
        item.put("type", 53);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 水表开阀() {
        String url = api2_url+"/Api_v2/water_control";

        // 请求内容，调用接口所需要的数据（水表开阀）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");
        item.put("type", 43);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 设置电表参数() {
        String url = api2_url+"/Api_v2/ele_write";

        // 请求内容，调用接口所需要的数据（一级报警值）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        Map<String, Object> params = new HashMap<>();
        params.put("p1", "300");

        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("type", 24);
        item.put("params", params);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 抄电表数据() {
        String url = api2_url+"/Api_v2/ele_read";

        // 请求内容，调用接口所需要的数据（抄电表数据）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        item.put("type", 3);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static void 抄水表数据() {
        String url = api2_url+"/Api_v2/water_read";

        // 请求内容，调用接口所需要的数据（抄水表数据）
        List<Map<String, Object>> req = new ArrayList<>();
        Map<String, Object> item = new HashMap<>();
        item.put("opr_id", generateOperateId());
        item.put("time_out", 0);
        item.put("must_online", true);
        item.put("retry_times", 1);
        item.put("cid", "88020206100");
        item.put("address", "C1E81000007859");
        item.put("type", 42);
        req.add(item);

        String request_content = JSON.toJSONString(req);
        testApiAsync(url, request_content);

    }

    private static String generateOperateId() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

    private static void 电能表档案查询()
    {
        String url = api2_url+"/Api_v2/ele_meter/query";
        // 请求内容，调用接口所需要的数据（查询指定的采集器下的电能表信息）
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "12345678901");     // 查询其他区域的采集器下的电能表(未找到采集器)
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "29020618114");     // 查询不存在的采集器下的电能表(未找到采集器)
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "19020618114");     // 查询本区域已经添加的采集器下的电能表(得到正确结果："address":["000066660942"])
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "1902061811411");   // 查询不合法的采集器下的电能表(只支持11/12位采集器号)
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }


    private static void 电能表删除()
    {
        String url = api2_url+"/Api_v2/ele_meter/delete";
        // 请求内容，调用接口所需要的数据(删除指定的电能表信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "0000666609");      // 不合法的表号
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "1902061811");          // 不合法的采集器号
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "12345678901");         // 非本区域采集器号
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "11335577990");
        item.put("address", "000066660942");    // 不存在的采集器号
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 电能表添加()
    {
        String url = api2_url+"/Api_v2/ele_meter/add";
        // 请求内容，调用接口所需要的数据(添加指定的电能表信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "0000666609");      // 不合法的表号
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "1902061811");          // 不合法的采集器号
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "12345678901");         // 非本区域采集器号
        item.put("address", "000066660942");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "11335577990");
        item.put("address", "000066660942");    // 不存在的采集器号
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }
    private static void 水表档案查询()
    {
        String url = api2_url+"/Api_v2/water_meter/query";
        // 请求内容，调用接口所需要的数据（查询指定的采集器下的水表信息）
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "19020618114");
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }


    private static void 水表删除()
    {
        String url = api2_url+"/Api_v2/water_meter/delete";
        // 请求内容，调用接口所需要的数据(删除指定的水表信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 水表添加()
    {
        String url = api2_url+"/Api_v2/water_meter/add";
        // 请求内容，调用接口所需要的数据(添加指定的水表信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "19020618114");
        item.put("address", "000066660942");
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 操作状态查询()
    {
        String url = api2_url+"/Api_v2/request/status";
        // 请求内容，调用接口所需要的数据(操作状态查询)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("opr_id", "123456");
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 取消操作()
    {
        String url = api2_url+"/Api_v2/request/cancel";
        // 请求内容，调用接口所需要的数据(取消操作)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("opr_id", "123456");
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }


    private static void 采集器删除()
    {
        String url = api2_url+"/Api_v2/collector/delete";
        // 请求内容，调用接口所需要的数据(删除指定的采集器信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "12345678901");     // 删除其他区域的采集器
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "29020618114");     // 删除不存在的采集器
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "19020618114");     // 删除本区域已经添加的采集器
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "1902061811411");   // 删除不合法的采集器
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 采集器添加()
    {
        String url = api2_url+"/Api_v2/collector/add";
        // 请求内容，调用接口所需要的数据(添加指定的采集器信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "12345678901");     // 采集器号被其他区域用户添加过的
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "19020618114");     // 多次调用均会返回添加成功
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void 查询全部采集器()
    {
        String url = api2_url+"/Api_v2/collector/query";
        // 请求内容，调用接口所需要的数据（查询所有采集器信息）
        String request_content = "[]";

        testApi(url, request_content);
    }
    private static void 查询N个采集器()
    {
        String url = api2_url+"/Api_v2/collector/query";
        // 请求内容，调用接口所需要的数据(查询指定的采集器信息)
        List<Map<String, String>> req = new ArrayList<>();
        Map<String, String> item = new HashMap<>();
        item.put("cid", "100000000101");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "10000000101");
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "1000000101");      // 采集器号不符合规范
        req.add(item);
        item = new HashMap<>();
        item.put("cid", "50000000101");     // 不存在的采集器
        req.add(item);
        String request_content = JSON.toJSONString(req);

        testApi(url, request_content);
    }

    private static void testApi(String url, String request_content)
    {
        String name=Thread.currentThread().getStackTrace()[2].getMethodName();
        System.out.println(name);

        String response = request(url, request_content);
        printResponse(response);
    }

    private static void testApiAsync(String url, String request_content)
    {
        String name=Thread.currentThread().getStackTrace()[2].getMethodName();
        System.out.println(name);

        String response = requestAsync(url, request_content);
        printResponse(response);
    }

    // 打印响应内容
    private static void printResponse(String response) {
        JSONObject jsonObject = JSON.parseObject(response);

        String status = jsonObject.getString("status");
        if(!"SUCCESS".equals(status)) {
            System.out.println(jsonObject.getString("error_msg"));
        } else {
            String response_content = jsonObject.getString("response_content");
            System.out.println("response_content: " + response_content);
            JSONArray contentArray = JSON.parseArray(response_content);
            int index = 1;
            System.out.println("返回结果：");
            for(int i = 0; i < contentArray.size(); ++i) {
                System.out.println("[" + index++ + "]");
                JSONObject contentObject = contentArray.getJSONObject(i);
                Set<String> keySet = contentObject.keySet();
                for(String key: keySet) {
                    System.out.println(key + ": " + contentObject.get(key));
                }

            }
        }
    }

    // 请求接口
    private static String request(String url, String request_content){
        // 时间戳
        String timestamp = String.valueOf(new Date().getTime()/1000);

        // 用于签名的内容
        Map<String, String> data = new HashMap<>();
        data.put("timestamp", timestamp);
        data.put("auth_code", auth_code);
        data.put("request_content", request_content);

        // 获取签名
        String sign = getSign(data);

        data.put("sign", sign);

        try {
            return sendHttpRequest(url, data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    // 请求接口
    private static String requestAsync(String url, String request_content){
        // 时间戳
        String timestamp = String.valueOf(new Date().getTime()/1000);

        // 用于签名的内容
        Map<String, String> data = new HashMap<>();
        data.put("timestamp", timestamp);
        data.put("auth_code", auth_code);
        data.put("request_content", request_content);
        data.put("notify_url", notify_url);

        // 获取签名
        String sign = getSign(data);

        data.put("sign", sign);

        try {
            return sendHttpRequest(url, data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    // 生成签名字符串
    private static String getSign(Map<String, String> data)
    {
        // 获取关键字列表
        List<String> keys = new ArrayList<>(data.keySet());
        // 关键字列表排序
        keys.sort(Comparator.naturalOrder());
        StringBuilder sb = new StringBuilder();
        for (String key : keys)
        {
            // 取各个字段内容拼接字符串
            sb.append(data.get(key));
        }
        // 加上双方约定随机字符串
        String txt = sb.toString() + nonce;

        // 计算哈希值
        return getMD5(txt);
    }

    // md5加密
    private static String getMD5(String password) {
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        byte[] byteArray = password.getBytes(StandardCharsets.UTF_8);

        byte[] md5Bytes = md5.digest(byteArray);
        StringBuilder hexValue = new StringBuilder();
        for (byte md5Byte : md5Bytes) {
            int val = ((int) md5Byte) & 0xff;
            if (val < 16) {
                hexValue.append("0");
            }

            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }

    // 发送http请求
    private static String sendHttpRequest(String url, Map<String, String> bodyMap) throws Exception {
        System.out.println("请求地址：" + url);
        System.out.println("发送参数：" + bodyMap.toString());
        HttpClient client = HttpClientBuilder.create().build();
        HttpPost postRequest = new HttpPost(url);

        List<NameValuePair> nvps = new ArrayList<>();

        for(String key : bodyMap.keySet()) {
            nvps.add(new BasicNameValuePair(key,bodyMap.get(key)));
        }
        postRequest.setEntity(new UrlEncodedFormEntity(nvps,"utf-8"));


        int retry = 3;
        HttpResponse execute = null;
        while(retry-- > 0) {
            try {
                execute = client.execute(postRequest);
                break;
            } catch (Exception e) {
                Thread.sleep(5000);
            }
        }
        if(execute == null) {
            throw new Exception("接口请求失败");
        }
        String resp = EntityUtils.toString(execute.getEntity(), "UTF-8");
        System.out.println("接口返回：" + resp);
        return resp;
    }

}