const router = require("koa-router")();
const mysql = require("../utils/mysql_db");
const jpush = require("../utils/jpush");

router.prefix("/apicloud");

let map_timeout = {}; //心跳超时检测

const multer = require("koa-multer"); //加载koa-multer模块
//文件上传
//配置
var storage = multer.diskStorage({
  //文件保存路径
  destination: function(req, file, cb) {
    cb(null, "public/uploads/");
  },
  //修改文件名称
  filename: function(req, file, cb) {
    var fileFormat = file.originalname.split(".");
    cb(null, Date.now() + "." + fileFormat[fileFormat.length - 1]);
  }
});
//加载配置
var upload = multer({
  storage: storage
});

/**
 * 上传录音文件
 * 传入参数 file
 */
router.post("/upload", upload.single("file"), async (ctx, next) => {
  if (ctx.req.file) {
    //TODO 语音识别
    //AipSpeechClient.recognize(ctx.req.file.filename);
    ctx.body = {
      success: true,
      filename: ctx.req.file.filename //返回文件名
    };
  } else {
    ctx.body = {
      success: false
    };
  }
});

//下发即时任务/apicloud/jpush?alias=123456780000432&commond=record&extra={"freq":"98","length":10000}
router.get("/jpush", async function(ctx, next) {
  let params = ctx.query;
  let devices = JSON.parse(params.devices);
  if (params.command == "scan") {
    //扫台
    setDeviceStatus(devices, "2"); //更新设备状态 2：扫台
    // let extra = JSON.parse(params.extra)
    //生成并插入即时任务
    let sql = `INSERT INTO fm_t_realtime_task(device_list,command,freq_range,recording_length,create_time,detail)
                  VALUES('${JSON.stringify(devices)}',
                         '扫台',
                         ${JSON.stringify(params.freq_range)},
                         ${params.length},
                         NOW(),
                         ${
                           params.detail
                             ? "".concat("'", params.detail, "'")
                             : "null"
                         }
                        );`;
    let result = await mysql.queryNewId(sql);
    console.log(result);
    //下发扫台指令
    let extra = {};
    extra.identifier = {
      task_type: "即时任务",
      task_id: result[0].new_id
    };
    extra.title = "updateTask";
    extra.task_id = result[0].new_id;
    if (params.length == "0") {
      console.log(params.length);
      extra.isNeedRecording = false;
    } else {
      console.log(params.length);
      extra.isNeedRecording = true;
    }

    extra.isPeriodTask = false;
    extra.startTime = "04:00:00";
    extra.endTime = "03:27:00";
    extra.recordSeconds = params.length * 1000;
    let freq = JSON.parse(params.freq_range);
    extra.startFrequency = freq[0];
    extra.endFrequenty = freq[1];

    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        sendDevices.push(devices[i]);
      }
    }

    // console.log(sendDevices);

    jpush.pushWithAlias(sendDevices.join(","), "updateTask", extra);
    params.logDes = `对编号为${params.devices}的设备下发扫台任务。`;
    ctx.body = {
      code: 20000,
      task_id: result[0].new_id
    };
  } else if (params.command == "record") {
    //录音
    setDeviceStatus(devices, "3"); //更新设备状态
    let extra = JSON.parse(params.extra);
    //生成并插入即时任务
    let sql = `INSERT INTO fm_t_realtime_task(device_list,command,create_time,detail,freq_range,recording_length)
                  VALUES('${JSON.stringify(devices)}',
                         '录音',
                         NOW(),
                         ${
                           params.detail
                             ? "".concat("'", params.detail, "'")
                             : "null"
                         },
                         ${extra.freq},
                         ${extra.length}
                        );`;
    let result = await mysql.queryNewId(sql);
    //按设备依次插入任务执行记录并下发录音指令
    // let task_id = result[0].new_id //即时任务id
    //   sql = `INSERT INTO fm_t_task_record(task_type,task_id,device_lgid,start_time) VALUES
    //   ('即时任务', '${task_id}', '${devices[i]}', NOW());`
    //   result = await mysql.queryNewId(sql)
    let task_record_id = result[0].new_id;
    //添加数据标识
    extra.identifier = {
      task_type: "即时任务",
      task_record_id: task_record_id,
      result_type: 0
    };
    extra.title = "updateTask";
    extra.task_id = result[0].new_id;
    extra.isNeedRecording = true;
    extra.isPeriodTask = false;
    extra.startTime = "04:00:00";
    extra.endTime = "03:27:00";
    extra.recordSeconds = params.extra.length * 1000;

    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        // let task_id = result[0].new_id //即时任务id
        // sql = `INSERT INTO fm_t_task_record(task_type,task_id,device_lgid,start_time) VALUES
        // ('即时任务', '${task_id}', '${devices[i]}', NOW());`
        // result = await mysql.queryNewId(sql)
        sendDevices.push(devices[i]);
      }
    }
    // console.log(sendDevices);

    jpush.pushWithAlias(sendDevices.join(","), "updateTask", extra); //extra中的录音长度单位为毫秒
    params.logDes = `对编号为${params.devices}的设备下发录音任务。`;

    ctx.body = {
      code: 20000,
      task_id: task_record_id
    };
  } else if (params.command == "reboot") {
    //重启
    params.logDes = `对编号为${params.devices}的设备下发重启任务。`;

    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        sendDevices.push(devices[i]);
      }
    }

    jpush.pushWithAlias(sendDevices.join(","), "reboot", params);
    ctx.body = {
      code: 20000
    };
  } else if (params.command == "periodicTasks") {
    setDeviceStatus(devices, "2"); //更新设备状态
    // let par = JSON.parse(params.extra)
    //生成并插入即时任务
    let sql = `INSERT INTO fm_t_realtime_task(device_list,command,freq_range,recording_length,create_time,detail)
                  VALUES('${JSON.stringify(devices)}',
                         '周期任务',
                         ${JSON.stringify(params.freq)},
                         ${params.length},
                         NOW(),
                         ${
                           params.detail
                             ? "".concat("'", params.detail, "'")
                             : "null"
                         }
                        );`;

    let result = await mysql.queryNewId(sql);
    //下发周期任务指令
    let extra = {};
    extra.identifier = {
      task_type: "周期任务",
      task_id: result[0].new_id
    };
    extra.title = "updateTask";
    extra.task_id = result[0].new_id;
    extra.isNeedRecording = true;
    extra.isPeriodTask = true;
    extra.startTime = "04:00:00";
    extra.endTime = "03:27:00";
    extra.recordSeconds = params.length * 1000;
    extra.period_seconds = params.periodLength * 1000 * 60;
    let freq = JSON.parse(params.freq);
    extra.startFrequency = freq[0];
    extra.endFrequenty = freq[1];

    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        sendDevices.push(devices[i]);
      }
    }
    // console.log(sendDevices);

    jpush.pushWithAlias(sendDevices.join(","), "updateTask", extra);
    params.logDes = `对编号为${params.devices}的设备下发周期任务。`;
    ctx.body = {
      code: 20000,
      task_id: result[0].new_id
    };
  } else if (params.command == "installApp") {
    //重启
    params.logDes = `对编号为${params.devices}的设备下发更新设备。`;

    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        sendDevices.push(devices[i]);
      }
    }

    jpush.pushWithAlias(sendDevices.join(","), "installApp", params);
    ctx.body = {
      code: 20000
    };
  } else if (params.command == "restartApp") {
    //重启
    params.logDes = `对编号为${params.devices}的设备下发重启App。`;
    // console.log(devices.join(','))
    let sendDevices = [];
    for (let i = 0; i < devices.length; i++) {
      if (devices[i]) {
        sendDevices.push(devices[i]);
      }
    }

    jpush.pushWithAlias(sendDevices.join(","), "restartApp", params);
    ctx.body = {
      code: 20000
    };
  }
});

//设备程序启动上报接口
router.get("/appLoaded", async function(ctx, next) {
  let params = ctx.query;
  let sql = `SELECT  log_id FROM fm_t_device  WHERE phy_id='${params.id}';`;
  let result = await mysql.query(sql);

  if (result.length == 1) {
    ctx.session.log_id = result[0].log_id;
    sql = `UPDATE fm_t_device set status=1 WHERE log_id='${ctx.session.log_id}'`;
    params.logDes = `设备${ctx.session.log_id}启动上报。`;
    mysql.query(sql);
    ctx.body = {
      device_id: result[0].log_id,
      code: 20000
    };
  } else {
    ctx.body = {
      success: false
    };
  }
});

//设备心跳接口
router.get("/heartBeat", async function(ctx, next) {
  let params = ctx.query;

  //插入数据库
  let sql = `INSERT INTO fm_t_heartbeat
      (device_lgid,battery,lon,lat,upload_time) VALUES
      (
      '${ctx.session.log_id}',
      '${params.battery}',
      ${params.lon},
      ${params.lat},
      NOW()
      )`;
  await mysql.query(sql);

  //获取心跳间隔
  sql = `SELECT heartbeat from fm_t_device WHERE log_id='${ctx.session.log_id}'`;
  let result = await mysql.query(sql);
  let interval = result[0].heartbeat;
  params.logDes = `设备${ctx.session.log_id}设置心跳。`;
  ctx.body = {
    code: 20000,
    interval: interval
  };

  //心跳超时检测
  if (typeof map_timeout[ctx.session.log_id] != "undefined")
    clearTimeout(map_timeout[ctx.session.log_id]);
  map_timeout[ctx.session.log_id] = setTimeout(function() {
    sql = `UPDATE fm_t_device set status=0 WHERE log_id='${ctx.session.log_id}'`;
    mysql.query(sql);
  }, interval * 60 * 1000 + 30000);
});

/**
 * 设备周期任务获取接口
 * 需要返回下一次任务执行时间 next
 */
router.get("/PeriodicTask", async function(ctx, next) {
  let log_id = ctx.session.log_id; //设备逻辑号
  let time = -1; //下一次执行任务时间

  //获取周期任务id 和 period
  let sql = `SELECT id,period FROM fm_t_period_task WHERE id = (SELECT task_id FROM fm_t_device WHERE log_id = '${log_id}');`;
  let result = await mysql.query(sql);

  if (result.length > 0) {
    time = f_next(0, result[0].period * 60000); //计算任务时间
  }
  if (time != -1) {
    ctx.body = {
      success: true,
      next: time,
      identifier: {
        task_type: "周期任务",
        task_id: result[0].id
      } // 数据标识
    };
  } else {
    ctx.body = {
      success: false
    };
  }
});

//错误上报
router.get("/error", async function(ctx, next) {
  //TODO 数据库插入错误记录

  //返回是否需要重启应用程序
  ctx.body = {
    success: true,
    reboot: false
  };
});

/**上传扫台结果
 * 传入参数：result(扫台结果 字符串 &分割频率)  start(扫台开始时间 字符串) end(扫台结束时间) lon lat  ,
 */
router.get("/ReportScanResult", async function(ctx, next) {
  /**
   * 扫台记录保存流程：
   * 1 将扫台结果保存到任务记录表（fm_t_task_record）中
   * 2 如果是周期任务，则返回需要录音的频率列表；此外还需返回录音频率对应的标识，标识包括：
   *   i  task_record_id，即1中插入新的任务记录后得到的主键id
   *   ii result_type，即频率的判别类型（取值为字典表fm_d_result_type中的id值）
   */
  let log_id = ctx.session.log_id;
  let params = ctx.query;
  params.identifier = JSON.parse(params.identifier);
  let scan_result = params.result
    .split("&")
    .map(freq => Math.round(Number(freq) * 10) / 10);

  //保存任务执行记录及扫台结果(不需要区分周期任务和即时任务的扫台)
  let sql = `INSERT INTO fm_t_task_record(task_type,task_id,device_lgid,start_time,finish_time,scan_result)
               VALUES('${params.identifier.task_type}',
                      '${params.identifier.task_id}',
                      '${log_id}',
                      '${params.start}',
                      '${params.end}',
                      '${JSON.stringify(scan_result)}'
                     );`;
  let query_result = await mysql.queryNewId(sql);
  let task_record_id = query_result[0].new_id;

  //处理即时任务结果
  if (params.identifier.task_type == "即时任务") {
    setDeviceStatus([log_id], "1"); //完成扫台 更新状态为 空闲
  }
  //处理周期任务的扫台结果
  if (params.identifier.task_type == "周期任务") {
    //获取任务配置
    let sql = `SELECT freq_range,whitelist,recording_length FROM fm_t_period_task WHERE id=${params.identifier.task_id}`;
    let result = await mysql.query(sql);
    let freq_range = result[0].freq_range
      ? JSON.parse(result[0].freq_range)
      : null;
    let whitelist = result[0].whitelist
      ? JSON.parse(result[0].whitelist)
      : null;
    let recording_length = result[0].recording_length;

    //筛选出在任务扫描频率范围内的频率
    let freq_in_range = [];
    for (let i = 0; i < scan_result.length; i++) {
      const frequency = scan_result[i];
      if (f_inRanges(frequency, freq_range)) {
        freq_in_range.push(frequency);
      }
    }

    //根据白名单判断频率是否合法

    let freq_list = []; //需要录音的频率
    let identifier_list = []; //录音频率对应的数据标识
    if (whitelist && JSON.stringify(whitelist) != "{}") {
      //当任务白名单不为空时，利用白名单判断频率的合法性

      let whitelist_map = await getWhitelist(whitelist); //白名单详细数据
      //由于任务白名单保存的是白名单id，先获取白名单频率到id的映射
      let freq_map = {};
      for (let whitelist_id in whitelist) {
        freq_map[whitelist_map[whitelist_id].frequency] = whitelist_id;
      }
      //对扫台结果的频率进行逐个判别
      for (let i = 0; i < freq_in_range.length; i++) {
        const freq = freq_in_range[i];
        if (freq_map[freq] == undefined) {
          //当频率不在任务白名单中时
          //直接将频率分类为非法电台
          freq_list.push(freq);
          identifier_list.push({
            task_type: "周期任务",
            task_record_id: task_record_id,
            result_type: 2 //类型：频率非法
          });
        } else {
          //当频率在任务白名单中时
          const wid = freq_map[freq]; //频率所对应的白名单id
          let time_legal = true; //时间合法性
          let area_legal = true; //区域合法性

          //判断时间是否合法
          let task_time = new Date(params.start); //任务开始时间
          let i_day = task_time.getDay(); //星期
          i_day = i_day == 0 ? 7 : i_day;
          if (whitelist_map[wid].runtime) {
            //如果设置了运行时
            const runtime_day = whitelist_map[wid].runtime[i_day];
            if (runtime_day && runtime_day.length > 0) {
              //如果设置了当天的运行时
              let i_hour = task_time.getHours();
              time_legal = false;
              for (let index = 0; index < runtime_day.length; index++) {
                if (i_hour == runtime_day[index]) {
                  time_legal = true;
                  break;
                }
              }
            } else {
              //如果当天的运行时未设置，则判别为非法
              time_legal = false;
            }
          } else {
            //如果没有设置运行时，则直接判别频率不合法
            time_legal = false;
          }

          //TODO: 判断区域是否合法

          //合法性判别
          if (time_legal && area_legal) {
            //如果时间区域均合法且设置了录音
            if (whitelist[wid] * 1) {
              freq_list.push(freq);
              identifier_list.push({
                task_type: "周期任务",
                task_record_id: task_record_id,
                result_type: 1 //类型：合法电台
              });
            }
          } else {
            //优先判别时间合法性（即：如果时间非法则不再判断区域非法）
            if (!time_legal) {
              freq_list.push(freq);
              identifier_list.push({
                task_type: "周期任务",
                task_record_id: task_record_id,
                result_type: 3 //类型：时间非法
              });
            } else {
              freq_list.push(freq);
              identifier_list.push({
                task_type: "周期任务",
                task_record_id: task_record_id,
                result_type: 4 //类型：区域非法
              });
            }
          }
        }
      }
    } else {
      //当任务的白名单为空时，则将全部扫描结果判定为非法电台
      for (let i = 0; i < freq_in_range.length; i++) {
        const freq = freq_in_range[i];
        freq_list.push(freq);
        identifier_list.push({
          task_type: "周期任务",
          task_record_id: task_record_id,
          result_type: 2 //类型：频率非法
        });
      }
    }
    ctx.body = {
      success: true,
      gray_list: freq_list, //需要录音的频率数组
      identifier_list: identifier_list, //录音命令对应的数据标识
      recording_length: recording_length //秒
    };
  }
  ctx.body = {
    success: true,
    gray_list: []
  };
});

//录音结果上报
router.get("/ReportRecordResult", async function(ctx, next) {
  let params = ctx.query;
  const identifier = JSON.parse(params.identifier);
  let sql = `INSERT INTO fm_t_scan_record(task_record_id,frequency,lon,lat,signal_strength,radio_file_path,result,upload_time)
               VALUES(${identifier.task_record_id},
                      ${Math.round(params.frequency * 10) / 10},
                      ${params.lon},
                      ${params.lat},
                      ${params.rssi},
                      '/uploads/${params.file}',
                      '${identifier.result_type}',
                      '${params.start}'
                     );`;
  mysql.query(sql);
  //由于即时任务的录音，其task_record 和 scan_record是一对一的
  //所以对于即时录音任务，在录音完成后可更新任务记录表中的任务结束时间
  if (identifier.task_type == "即时任务") {
    setDeviceStatus([ctx.session.log_id], "1"); //完成录音 更新状态为 空闲
    sql = `UPDATE fm_t_task_record SET finish_time='${params.end}' WHERE id=${identifier.task_record_id};`;
    mysql.query(sql);
  }
  ctx.body = {
    success: true
  };
});

/**
 * 计算下一个周期任务的执行时间
 * @param {number} start 起算点（时间戳）
 * @param {number} period 周期
 * @param {number} end 结束点（时间戳）
 */
function f_next(start, period, end) {
  let t = Math.ceil((Date.now() - start) / period) * period + start;
  if (end) {
    t = t <= end ? t : -1;
  }
  return t;
}

/**
 * 判断目标频率是否在频率区间内
 * @param {number} target 目标频率
 * @param {Array<Array<number>>} ranges 扫描频率范围
 */
function f_inRanges(target, ranges) {
  target = target * 1;
  for (let i = 0; i < ranges.length; i++) {
    const range = ranges[i];
    if (range.length == 1) {
      if (target == range[0]) return true;
    } else if (range.length == 2) {
      if (target >= range[0] && target <= range[1]) return true;
    } else {
      console.log("警告");
    }
  }
  return false;
}

/**
 * 获取任务白名单的详细信息
 * @param {JSON} whitelist_of_task 任务白名单
 */
async function getWhitelist(whitelist_of_task) {
  let ids = [];
  for (let id in whitelist_of_task) {
    ids.push(id);
  }
  let sql = `SELECT id,frequency,runtime,area from fm_t_whitelist where id IN (${ids.join(
    ","
  )});`;
  let result = await mysql.query(sql);
  whitelist_map = {};
  for (let i = 0; i < result.length; i++) {
    let element = result[i];
    if (element.runtime) {
      element.runtime = JSON.parse(element.runtime);
      //处理运行时为空对象的情况（正常情况下是不应该有这种情况的）
      if (JSON.stringify(element.runtime) == "{}") {
        element.runtime = null;
      }
    }
    whitelist_map[element.id] = element;
  }
  return whitelist_map;
}

/**
 * 设置设备的状态（主要用于下发即时任务和完成任务时改变设备的状态）
 * @param {Array<String>} device_list 设备逻辑号列表
 * @param {String} status 设备状态
 */
function setDeviceStatus(device_list, status) {
  let sql = `UPDATE fm_t_device SET status='${status}' WHERE log_id IN ('${device_list.join(
    "','"
  )}');`;
  mysql.query(sql);
}

module.exports = router;