/* eslint-disable no-bitwise */
const debug = require('debug')('ctrl:common')
const util = require('util')
const joi = require('joi')
const response = require('src/utils/response/index.js')
const config = require('src/config/index.js')
const { jwt } = require('src/utils/pkgs.js')
const { copyObject, toNumber } = require('src/utils/index.js')

const { Success, InternalError, DataFormat, Forbidden, Unauthorized } = response.resp

const controller = {}
module.exports = controller

/**
 * api reponse function
 * @param {import('src/utils/response/index.js').respObject} resp
 * @param {string|Object} body
 */
function responseFunc (resp, body) {
  /** @type {import('src/utils/response/index.js').respObject} */
  const copy = copyObject(response.checkStruct(resp) ? resp : Success)

  if (typeof body === 'string') copy.object.message = body
  else if (typeof body === 'object') copy.object = body

  // @ts-ignore
  if (!('obj' in this)) this.obj = {}
  this.obj.status = copy.status
  this.obj.object = copy.object
}

/**
 * api error response function
 * @param {import('src/utils/response/index.js').respObject} resp
 * @param {import('src/utils/response/index.js').codeMessage=} code
 */
function responseError (resp, code) {
  /** @type {import('src/utils/response/index.js').respObject} */
  const copy = copyObject(response.checkStruct(resp) ? resp : InternalError)

  if (code && typeof code === 'object' && 'message' in code && 'code' in code) {
    copy.object = code
  }

  const err = new response.APIError(copy.object.message, copy)
  throw err
}

controller.apiHandler = () => async (ctx, next) => {
  ctx.obj = {}
  ctx.token = {}

  ctx.resp = responseFunc.bind(ctx)
  ctx.err = responseError

  ctx.getBody = key => (ctx.request.body || {})[key]
  ctx.getFile = key => (ctx.request.files || {})[key]

  // run next
  try {
    await next()
  } catch (err) {
    debug(`Get API Throw Error: ${util.inspect(err, false, null)}`)
    // debug(err.stack);
    if (!(err instanceof response.APIError)) {
      ctx.resp(InternalError)
    } else {
      ctx.obj = err.object
    }

    if (process.env.NODE_ENV !== 'production') {
      ctx.obj.object.errorStack = err.stack
      ctx.obj.object.errorMessage = err.message
    }
  }

  if (Object.keys(ctx.obj).length > 0) {
    ctx.status = ctx.obj.status
    ctx.body = ctx.obj.object
  }
}

/**
 * data validate middleware
 * @param {{query?: any, header?: any, body?: any}} schema body,query and header is joi.Schema
 */
controller.validate = schema => {
  if (typeof schema !== 'object') responseError(InternalError)
  const v = {}
  if ('body' in schema) v.body = joi.isSchema(schema.body) ? schema.body : joi.object(schema.body).unknown()
  if ('header' in schema) v.header = joi.isSchema(schema.header) ? schema.header : joi.object(schema.header).unknown()
  if ('query' in schema) v.query = joi.isSchema(schema.query) ? schema.query : joi.object(schema.query).unknown()

  return async (ctx, next) => {
    try {
      await joi.object(v).unknown().validateAsync({ query: ctx.query, header: ctx.headers, body: ctx.request.body })
    } catch (err) {
      debug(`data validate error: ${util.inspect(err, false, null)}`)
      responseError(DataFormat)
    }
    return next()
  }
}

/**
 * @param {boolean=} allowExpired
 * @return {import('koa').Middleware}
 */
controller.authorization = allowExpired => {
  return async (ctx, next) => {
    ctx.token = {}
    /** @type {string} */
    const token = ctx.get('authorization')

    if (!token) ctx.err(Unauthorized)

    try {
      const strs = token.split(/\s/)
      debug(`Get Header: ${token}`)
      if (strs.length !== 2 || !/^bearer$/i.test(strs[0])) ctx.err(Unauthorized, response.codeMessage.CodeTokenInvalid);

      [, ctx.token.origin] = strs

      let decoded = {}
      let expired = false

      try {
        decoded = jwt.verify(strs[1], config.server.jwt_secret)

        await joi
          .object({
            user_id: joi.string().required()
          })
          .unknown()
          .validateAsync(decoded)
      } catch (err) {
        debug(`jwt token verify fail: ${util.inspect(err, false, null)}`)
        if (err instanceof jwt.TokenExpiredError) {
          decoded = jwt.decode(ctx.token.origin)
          expired = true
        } else {
          throw err
        }
      }

      ctx.token.user_id = decoded.user_id
      ctx.token.sso = !!decoded.sso

      if (expired) ctx.err(Forbidden, response.codeMessage.CodeTokenExpired)

      ctx.verified = true
    } catch (err) {
      debug(`Token valid fail: ${util.inspect(err, false, null)}`)
      if (err instanceof response.APIError) {
        // 如果是過期的錯誤，判斷是否允許過期存取
        // @ts-ignore
        // eslint-disable-next-line
        if (err._object?.object?.code === response.codeMessage.CodeTokenExpired.code) {
          if (allowExpired) return next()
        }
      }
      throw err
    }

    return next()
  }
}