const moment = require('moment')

module.exports = function (app, opts) {
   const alarmsPush = app.fs.scheduleInit(
      {
         interval: '12 */1 * * * *',
         immediate: true, // dev
         proRun: true,
      },
      async () => {
         try {
            const { models, ORM: sequelize } = app.fs.dc
            const { clickHouse } = app.fs
            const { database: anxinyun } = clickHouse.anxinyun.opts.config
            const { pushBySms, pushByEmail } = app.fs.utils
            const curMinOfYear = moment().diff(moment().startOf('year'), 'minutes')
            const configListRes = await models.AlarmPushConfig.findAll({
               where: {
                  del: false
               },
               include: [{
                  model: models.ProjectCorrelation,
                  where: {
                     del: false
                  },
                  required: true
               }]
            })
            let pepProjectIds = new Set()
            for (let { dataValues: c } of configListRes) {
               if (c.projectCorrelation.pepProjectId) {
                  pepProjectIds.add(c.projectCorrelation.pepProjectId)
               }
            }
            const pepProjectRes = pepProjectIds.size ?
               await clickHouse.projectManage.query(
                  `
                     SELECT 
                        t_pim_project.id AS id, 
                        t_pim_project.project_name AS project_name, 
                        t_pim_project.isdelete AS isdelete,
                        t_pim_project_construction.construction_status_id AS construction_status_id, 
                        t_pim_project_state.construction_status AS construction_status 
                     FROM t_pim_project 
                        LEFT JOIN t_pim_project_construction 
                           ON t_pim_project.id = t_pim_project_construction.project_id 
                        LEFT JOIN t_pim_project_state 
                           ON t_pim_project_construction.construction_status_id = t_pim_project_state.id 
                        WHERE id IN (${[...pepProjectIds].join(',')})
                  `
               ).toPromise() :
               []

            for (let { dataValues: c } of configListRes) {
               if (c.tacticsParams && c.tactics) {
                  const { projectCorrelation, strucId } = c
                  const { interval, deviceProportion } = c.tacticsParams

                  if (
                     curMinOfYear % interval == 0
                  ) {
                     const corPepProject = projectCorrelation.pepProjectId ?
                        pepProjectRes.find(p => p.id == projectCorrelation.pepProjectId)
                        : null
                     if (
                        !projectCorrelation.pepProjectId
                        || (
                           corPepProject
                           && c.timeType.some(ct => ct == corPepProject.construction_status_id)
                        )
                     ) {
                        // TODO 查当前 poms 下的结构物 并把不包含的去掉
                        
                        const strucListRes = strucId.length ? await clickHouse.anxinyun.query(`
                           SELECT id, iota_thing_id, name
                           FROM t_structure
                           WHERE id IN (${strucId.join(',')})
                        `).toPromise() : []

                        let dataAlarmOption = []
                        let dataAlarmGroupOption = []
                        let dataAlarms = []

                        let videoAlarms = []

                        let deviceCount = 0
                        let cameraCount = 0
                        // 判断推送策略
                        let pointTime = moment().subtract(interval, 'minute').format('YYYY-MM-DD HH:mm:ss')
                        if (c.tactics == 'immediately') {
                           dataAlarmOption.push(`StartTime >= '${pointTime}'`);
                        } else if (c.tactics == 'continue') {
                           dataAlarmOption.push(`StartTime <= '${pointTime}'`);
                        } else if (c.tactics == 'abnormal_rate') {
                           dataAlarmOption.push(`StartTime <= '${pointTime}'`);
                           if (c.alarmType.includes('data_outages') || c.alarmType.includes('data_exception')) {
                              // 查了设备异常率 去安心云查当前项目下的设备数量
                              // TODO 等同步以太数据再查
                              deviceCount = 9999
                              //    await clickHouse.anxinyun.query(`
                              //    SELECT count(*) FROM 
                              // `).toPromise()
                           }
                           if (c.alarmType.includes('video_exception')) {
                              // 查了视频异常 去安心云查 接入的 萤石 设备数量
                              cameraCount = strucId.length ?
                                 (await clickHouse.anxinyun.query(`
                                    SELECT count(*) AS count FROM t_video_ipc
                                    WHERE structure IN (${strucId.join(',')})
                                 `).toPromise())[0].count
                                 : 0
                           }
                        }

                        // 判断告警数据范围
                        if (c.alarmType.includes('data_outages')) {
                           dataAlarmGroupOption.push(1)
                        }
                        if (c.alarmType.includes('data_exception')) {
                           dataAlarmGroupOption.push(2)
                        }
                        if (c.alarmType.includes('strategy_hit')) {
                           dataAlarmGroupOption.push(3)
                        }
                        if (c.alarmType.includes('video_exception')) {
                           videoAlarms = strucId.length ? await clickHouse.vcmp.query(
                              `
                                 SELECT         
                                    cameraAlarm.cameraId AS cameraId,
                                    cameraAlarm.cameraName AS cameraName,
                                       cameraAlarm.cameraSerialNo AS cameraSerialNo,
                                       cameraAlarm.cameraChannelNo AS cameraChannelNo,
                                    cameraAlarm.alarmId AS alarmId,
                                    cameraAlarm.createTime AS createTime,
                                    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,
                                       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_status_alarm.id AS alarmId,
                                          camera_status_alarm.create_time AS createTime,
                                          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 ${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
                                          AND ${anxinyun}.t_video_ipc.structure IN (${strucId.join(',')})
                                       INNER JOIN camera
                                          ON camera.serial_no = camera_status_alarm.serial_no
                                          AND camera.channel_no = camera_status_alarm.channel_no
                                       WHERE 
                                          camera.delete = false 
                                          AND camera.recycle_time is null
                                    ) 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 ${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 (${strucId.join(',')})
                                 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 videoAlarms) {
                              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,

                                    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
                                 }
                              }
                           }
                           let p = 1
                        }
                        if (c.alarmType.includes('app_exception')) {

                        }
                        if (c.alarmType.includes('device_exception')) {
                           dataAlarmGroupOption.push(4)
                           dataAlarmGroupOption.push(5)
                        }
                        // 
                        if (dataAlarmGroupOption.length) {
                           dataAlarmGroupOption.push(-1)
                           dataAlarmOption.push(`AlarmGroup IN (${dataAlarmGroupOption.join(',')})`)
                           dataAlarms = await clickHouse.dataAlarm.query(`
                              SELECT * FROM alarms 
                                 WHERE 
                                    State NOT IN (3, 4) 
                                    ${dataAlarmOption.length ? ' AND ' + dataAlarmOption.join(' AND ') : ''}
                           `).toPromise()
                           console.log(dataAlarms);
                        }


                     }
                  }
               }
            }

         } catch (error) {
            console.error(error);
         }
      }
   )

   return {
      alarmsPush,
   }
}