'use strict';
const moment = require('moment')

async function deviceType (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs

      const kindRes = await clickHouse.vcmp.query(`
         SELECT * FROM camera_kind
      `).toPromise()

      ctx.status = 200;
      ctx.body = kindRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function alarmList (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs
      const { utils: { judgeSuper, anxinStrucIdRange } } = ctx.app.fs
      const { database: anxinyun } = clickHouse.anxinyun.opts.config
      const { pepProjectId, keywordTarget, keyword, state, kindId, sustainTimeStart, sustainTimeEnd, limit, page, } = ctx.query

      let anxinStruc = await anxinStrucIdRange({
         ctx, pepProjectId, keywordTarget, keyword
      })
      const anxinStrucIds = anxinStruc.map(a => a.strucId)

      let cameraWhereOption = []
      if (keywordTarget == 'source' && keyword) {
         cameraWhereOption.push(`camera.name LIKE '%${keyword}%'`)
      }
      if (state) {
         if (state == 'new') {
            cameraWhereOption.push(`camera_status_alarm.confirm_time IS null`)
         } else if (state == 'histroy') {
            cameraWhereOption.push(`camera_status_alarm.confirm_time IS NOT null`)
         }
      }
      if (kindId) {
         cameraWhereOption.push(`camera.kind_id = ${kindId}`)
      }

      let statusAlarmWhereOption = []
      if (sustainTimeStart && sustainTimeEnd) {
         let momentStart = moment(sustainTimeStart).format('YYYY-MM-DD HH:mm:ss')
         let momentEnd = moment(sustainTimeEnd).format('YYYY-MM-DD HH:mm:ss')
         statusAlarmWhereOption.push(`
            (
               camera_status_alarm.create_time
                  BETWEEN '${momentStart}' AND '${momentEnd}' 
                  OR 
                  camera_status_alarm.update_time BETWEEN '${momentStart}' AND '${momentEnd}' 
                  OR (
                     camera_status_alarm.create_time <= '${momentStart}' 
                     AND 
                     camera_status_alarm.update_time >= '${momentEnd}'
                  )
            )
         `)
      }
      const alarmRes = anxinStrucIds.length ? await clickHouse.vcmp.query(
         `
            SELECT
               cameraAlarm.cameraId AS cameraId,
               cameraAlarm.cameraName AS cameraName,
               cameraAlarm.cameraKindId AS cameraKindId,
               cameraAlarm.venderId AS venderId,
               cameraAlarm.venderName AS venderName,
                  cameraAlarm.cameraSerialNo AS cameraSerialNo,
                  cameraAlarm.cameraChannelNo AS cameraChannelNo,
               cameraAlarm.alarmId AS alarmId,
               cameraAlarm.createTime AS createTime,
               cameraAlarm.updateTime AS updateTime,
               cameraAlarm.platform AS platform,
               cameraAlarm.confirmContent AS confirmContent,
               cameraAlarm.confirmTime AS confirmTime,
               ${'cameraAlarm.autoRestore AS autoRestore,'}
               camera_status_resolve.id AS resolveId,
               camera_status.describe AS statusDescribe,
               camera_status_resolve.resolve AS resolve,
               "gbCamera".online AS cameraOnline,
               secret_yingshi.token AS yingshiToken,
                  anxinIpc.t_video_ipc.name AS anxinIpcPosition,
                  anxinStation.id AS anxinStationId,
                  anxinStation.name AS anxinStationName,
                  anxinStruc.name AS strucName,
                  anxinStruc.id AS strucId
            FROM
               (
                  SELECT
                        camera.id AS cameraId,
                        camera.gb_id AS gbId,
                        camera.name AS cameraName,
                        camera.kind_id AS cameraKindId,
                        camera.vender_id AS venderId,
                        camera.yingshi_secret_id AS yingshiSecretId,
                        vender.name AS venderName,
                        camera_status_alarm.id AS alarmId,
                        camera_status_alarm.create_time AS createTime,
                        camera_status_alarm.update_time AS updateTime,
                        camera_status_alarm.platform AS platform,
                        camera_status_alarm.status_id AS statusId,
                        camera_status_alarm.serial_no AS cameraSerialNo,
                        camera_status_alarm.channel_no AS cameraChannelNo,
                        camera_status_alarm.confirm AS confirmContent,
                        ${'camera_status_alarm.auto_restore AS autoRestore,'}
                        camera_status_alarm.confirm_time AS confirmTime
                     FROM camera_status_alarm
                     INNER JOIN camera
                        ON camera.serial_no = camera_status_alarm.serial_no
                        AND camera.channel_no = camera_status_alarm.channel_no
                        ${cameraWhereOption.length ? 'AND ' + cameraWhereOption.join(' AND ') : ''}
                     LEFT JOIN vender
                        ON vender.id = camera.vender_id
                     WHERE 
                        camera.delete = false 
                        AND camera.recycle_time is null
                        ${statusAlarmWhereOption.length ? 'AND ' + statusAlarmWhereOption.join(' AND ') : ''}
                     AND alarmId IN (
                        SELECT camera_status_alarm.id AS alarmId 
                        FROM camera_status_alarm
                        RIGHT JOIN ${anxinyun}.t_video_ipc
                           ON toString(${anxinyun}.t_video_ipc.channel_no) = camera_status_alarm.channel_no
                           AND ${anxinyun}.t_video_ipc.serial_no = camera_status_alarm.serial_no
                           ${`WHERE ${anxinyun}.t_video_ipc.structure IN (${anxinStrucIds.join(',')})`
         }
                     )
                     ${limit ? 'LIMIT ' + limit : ''}
                     ${limit && page ? 'OFFSET ' + parseInt(limit) * parseInt(page) : ''}
               ) AS cameraAlarm
            LEFT JOIN camera_status
               ON cameraAlarm.platform = camera_status.platform
               AND cameraAlarm.statusId = camera_status.id
            LEFT JOIN camera_status_resolve
               ON camera_status_resolve.status_id = camera_status.id
            LEFT JOIN "gbCamera"
               ON "gbCamera".id = cameraAlarm.gbId
            LEFT JOIN "secret_yingshi"
               ON "secret_yingshi".id = cameraAlarm.yingshiSecretId

            LEFT JOIN ${anxinyun}.t_video_ipc AS anxinIpc
               ON toString(anxinIpc.channel_no) = cameraAlarm.cameraChannelNo
               AND anxinIpc.serial_no = cameraAlarm.cameraSerialNo
            LEFT JOIN ${anxinyun}.t_structure AS anxinStruc
               ON anxinStruc.id = anxinIpc.structure
               AND anxinStruc.id IN (${anxinStrucIds.join(',')})
               ${keywordTarget == 'struc' && keyword ? `AND anxinStruc.name LIKE '%${keyword}%'` : ''}
            LEFT JOIN ${anxinyun}.t_video_ipc_station AS anxinIpcStation
               ON anxinIpcStation.ipc = anxinIpc.id
            LEFT JOIN ${anxinyun}.t_sensor AS anxinStation
               ON anxinStation.id = anxinIpcStation.station
         `
      ).toPromise() : []

      let returnD = []
      let positionD = {}
      // 每个设备一个告警
      for (let a of alarmRes) {
         if (positionD[a.cameraId]) {
            let curD = returnD[positionD[a.cameraId].positionReturnD]
            if (a.resolveId && !curD.resolve.some(r => r.id == a.resolveId)) {
               curD.resolve.push({
                  id: a.resolveId,
                  resolve: a.resolve
               })
            }
            if (a.strucId && !curD.struc.some(s => s.id == a.strucId)) {
               curD.struc.push({
                  id: a.strucId,
                  projectId: a.projectId,
                  name: a.strucName
               })
            }
            if (a.anxinStationId && !curD.station.some(s => s.id == a.anxinStationId)) {
               curD.station.push({
                  id: a.anxinStationId,
                  name: a.anxinStationName,
                  position: a.anxinIpcPosition
               })
            }
         } else {
            let d = {
               cameraId: a.cameraId,
               cameraName: a.cameraName,
               camerOnline: a.cameraOnline,
               cameraSerialNo: a.cameraSerialNo,
               cameraChannelNo: a.cameraChannelNo,
               autoRestore: a.autoRestore,
               createTime: a.createTime,
               updateTime: a.updateTime,
               platform: a.platform,
               statusDescribe: a.statusDescribe,
               alarmId: a.alarmId,
               confirmContent: a.confirmContent,
               confirmTime: a.confirmTime,

               venderId: a.venderId,
               venderName: a.venderName,
               cameraKindId: a.cameraKindId,
               yingshiToken: a.yingshiToken,

               resolve: [],
               struc: [],
               station: []
            }

            // pep 项目
            d.pomsProject = (
               anxinStruc.find(as => as.strucId == a.strucId) ||
               {
                  pomsProject: [

                  ]
               }
            ).pomsProject

            if (a.resolveId) {
               d.resolve.push({
                  id: a.resolveId,
                  resolve: a.resolve
               })
            }
            if (a.strucId) {
               d.struc.push({
                  id: a.strucId,
                  projectId: a.projectId,
                  name: a.strucName
               })
            }
            if (a.anxinStationId) {
               d.station.push({
                  id: a.anxinStationId,
                  name: a.anxinStationName,
                  position: a.anxinIpcPosition
               })
            }
            returnD.push(d)
            positionD[a.cameraId] = {
               positionReturnD: returnD.length - 1
            }
         }
      }

      ctx.status = 200;
      ctx.body = returnD
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function confirm (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { alarmId, content } = ctx.request.body;

      // TODO: 以视频·应用的秘钥进行鉴权
      await ctx.app.fs.vcmpRequest.put('status/alarm/confirm', {
         data: {
            alarmId, content
         }
      })

      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function vcmpAppAuthToken (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { utils: { vcmpAuth } } = ctx.app.fs

      const token = await vcmpAuth()

      ctx.status = 200;
      ctx.body = { token }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

module.exports = {
   deviceType,
   alarmList,
   confirm,
   vcmpAppAuthToken
};