'use strict';


async function projectList (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const { limit, page, name, justStructure } = ctx.query;

      let options = {
         where: {

         },
         // include: [{
         //    as: 'company',
         //    model: models.Company,
         //    attributes: ['id', 'name'],
         // },],
      }
      if (limit) {
         options.limit = Number(limit)
      }
      if (page && limit) {
         options.offset = Number(page) * Number(limit)
      }
      if (name) {
         options.where.name = { $like: `%${name}%` }
      }

      let res = []
      if (justStructure) {
         res = await models.Project.findAndCountAll({
            attributes: ['id', 'name'],
         })
      } else {
         res = await models.Project.findAndCountAll(options)
      }

      ctx.status = 200;
      ctx.body = res
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取结构列表失败"
      }
   }
}


async function postAddProject (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const data = ctx.request.body;
      const { img, longitude, latitude, name, type, describe } = data

      let errMsg = data.id ? '结构物编辑失败' : '结构物新增失败'
      let project = { img, longitude, latitude, name, type, describe, userId: userInfo.id }

      const alikeProject = await models.Project.findOne({
         where: {
            name: name,
         }
      })

      if ((!data.id && alikeProject) || (alikeProject && alikeProject.id !== data.id)) {
         errMsg = '已有相同结构物名称'
         throw errMsg
      }
      if (data && data.id) {
         await models.Project.update(project, {
            where: {
               id: data.id
            }
         })
      } else {
         await models.Project.create(project)
      }


      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`)
      ctx.status = 400;
      ctx.body = {
         "message": errMsg
      }
   }
}

async function delProject (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const { id } = ctx.params

      //删除结构物
      await models.Project.destroy({
         where: {
            id,
         }
      })
      const pointId = []
      const pointLIst = await models.Point.findAll({
         where: {
            projectId: id,
         },
         attributes: ['id'],
      })
      pointLIst.map(v => pointId.push(v.id))

      //点位
      await models.Point.destroy({
         where: {
            projectId: id
         }
      })


      //巡检计划
      const planId = []
      const planLIst = await models.PatrolPlan.findAll({
         where: {
            structureId: id,
         },
         attributes: ['id'],
      })
      planLIst.map(v => planId.push(v.id))
      await models.PatrolPlan.destroy({
         where: {
            structureId: id
         }
      })

      //巡检记录
      await models.PatrolRecord.destroy({
         where: {
            pointId: { $in: pointId },
            patrolPlanId: { $in: planId }
         }
      })


      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`)
      ctx.status = 400;
      ctx.body = {
         "message": '删除结构物失败'
      }
   }
}

async function addPosition (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const data = ctx.request.body;
      const { longitude, latitude, name, describe, qrCode, projectId, } = data

      let errMsg = data.id ? '点位编辑失败' : '点位新增失败'
      let pointData = { longitude, latitude, name, describe, qrCode, projectId }

      const alikeProject = await models.Point.findOne({
         where: {
            id: data.id,
         }
      })

      if (data && data.id) {
         if (qrCode) {
            await models.Point.update({ ...alikeProject, qrCode }, {
               where: {
                  id: data.id,
               }
            })
         } else {
            await models.Point.update({ pointData }, {
               where: {
                  id: data.id,
               }
            })
         }

      } else {
         await models.Point.create(pointData)
      }


      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`)
      ctx.status = 400;
      ctx.body = {
         "message": errMsg
      }
   }
}

async function position (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const { limit, page, projectId } = ctx.query;

      let options = {
         where: {
            id: projectId
         },
         include: [{
            model: models.Point,
         },],
      }
      if (limit) {
         options.limit = Number(limit)
      }
      if (page && limit) {
         options.offset = Number(page) * Number(limit)
      }

      let res = await models.Project.findAndCountAll(options)
      ctx.status = 200;
      ctx.body = res
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取结构列表失败"
      }
   }
}

async function delPosition (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const { id } = ctx.params

      const pointOne = await models.Point.findOne({
         where: {
            id
         },
         attributes: ['projectId'],
      })
      if (pointOne) {
         const patrolPlanLIst = await models.PatrolPlan.findAll({
            where: {
               structureId: pointOne.id,
            },
            attributes: ['id', 'structureId', 'points'],
         })
         patrolPlanLIst.map(async v => {
            const points = []
            v.points.map(r => {
               if (r.id !== id) {
                  points.push(r)
               }
            })
            v.points = points

            await models.PatrolRecord.destroy({
               where: {
                  pointId: id,
                  patrolPlanId: v.id
               }
            })

            if (points.length > 0) {
               await models.PatrolPlan.create(v)
            } else {
               await models.PatrolPlan.destroy({
                  where: {
                     id: v.id
                  }
               })
            }

         })
      }

      await models.Point.destroy({
         where: {
            id,
         }
      })


      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`)
      ctx.status = 400;
      ctx.body = {
         "message": '删除点位失败'
      }
   }
}


async function qrCodeShow (ctx, next) {
   try {
      const models = ctx.fs.dc.models;
      let userInfo = ctx.fs.api.userInfo;
      const { projectId, name } = ctx.query;

      let options = {
         where: {
            qrCode: { $ne: null }
         },
      }
      if (projectId) {
         options.where.projectId = projectId
      }
      if (name) {
         options.where.name = { $like: `%${name}%` }
      }

      let res = await models.Point.findAndCountAll(options)
      ctx.status = 200;
      ctx.body = res
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取二维码列表失败"
      }
   }
}


async function q (ctx) {
   // let error = {
   //     name: 'FindError',
   //     message: "获取失败!"
   // };
   // const models = ctx.fs.dc.models;
   // const { devices } = ctx.request.body
   // const attachment = ctx.app.fs.qn_attachment

   // try {

   //     if (!Array.isArray(devices)) {
   //         error = { name: 'paramsError', message: '参数不能为空' };
   //         ctx.throw(400);
   //     }
   //     const devicesArr = await models.Device.findAll({
   //         attributes: ['deviceNo', 'periodCode', 'qrSrc'],
   //         where: { deviceNo: { $in: devices } }
   //     })

   //     let ids = [], idsMap = {}, qnImages = []
   //     devicesArr.forEach(d => {
   //         const qrSrc = d.qrSrc
   //         const deviceNo = d.deviceNo
   //         const periodCode = d.periodCode
   //         if (qrSrc) {
   //             if (/^\d+$/.test(qrSrc)) {
   //                 ids.push(qrSrc)
   //                 idsMap[qrSrc] = { deviceNo, periodCode }
   //             } else {
   //                 let domain = globalCache.getQnDomain()
   //                 let imgUrl = `${domain}/${qrSrc}`
   //                 qnImages.push({ src: imgUrl, deviceNo, periodCode })
   //             }
   //         }
   //     })

   //     const docs = await models.QrcodePng.findAll({
   //         where: {
   //             id: { $in: ids }
   //         },
   //         attributes: ["id", "base64"]
   //     })

   //     let pics = []

   //     if (docs.length > 0) {
   //         pics = docs.map((d) => {
   //             let { deviceNo, periodCode } = idsMap[d.id] || {}
   //             let base64 = d.base64.replace(/^data:image\/\w+;base64,/, '')
   //             return {
   //                 url: Buffer.from(base64, 'base64'),
   //                 name: deviceNo,
   //                 periodCode
   //             }
   //         })
   //     }

   //     if (qnImages.length > 0) {
   //         let qns = await downloadImgsAsBase64(qnImages)
   //         pics = pics.concat(qns)
   //     }

   //     let fileUrl = await downLoadImageBiz(pics, { zipName: "二维码_" + moment().format("YYYY-MM-DD-HH-mm-ss"), attachment })
   //     add2CleanCache(fileUrl, attachment)
   //     ctx.status = 200
   //     ctx.body = { fileUrl }

   // } catch (err) {
   //     ctx.fs.logger.error(err);
   //     ctx.status = 400;
   //     ctx.body = error;
   // }
}

module.exports = {
   projectList,
   postAddProject,
   delProject,
   addPosition,
   position,
   delPosition,
   qrCodeShow,
   q
}