import { LarkService } from "@egg/net-tool"
import Joi from "joi"

import { APP_MAP } from "../../constant/config"
import insertSheet from "../../controller/sheet/insert"
import { Context } from "../../types"
import { SheetProxy } from "../../types/sheetProxy"

/**
 * 校验表格请求的参数
 * @param {Context} ctx - 上下文数据，包含请求体和响应生成器
 * @returns {Promise<false | Response>} 如果校验失败，返回响应对象；否则返回 false
 */
const validateSheetReq = async ({
  body,
  genResp,
}: Context): Promise<false | Response> => {
  // 定义基础的Schema
  let schema = Joi.object({
    api_key: Joi.string()
      .required()
      .messages({ "any.required": "api_key is required" }),
    sheet_token: Joi.string()
      .required()
      .messages({ "any.required": "sheet_token is required" }),
    range: Joi.string()
      .required()
      .messages({ "any.required": "range is required" }),
    type: Joi.string()
      .required()
      .custom((value, helpers) => {
        if (!SheetProxy.isType(value)) {
          return helpers.error("any.invalid")
        }
        return value
      })
      .messages({
        "any.required": "type is required",
        "any.invalid": "type is invalid",
      }),
  })

  if (body.type === "insert") {
    schema = schema.keys({
      values: Joi.array()
        .items(Joi.array().items(Joi.string()))
        .required()
        .messages({ "any.required": "values is required" }),
    })
  }

  // 校验参数
  const { error } = schema.validate(body)
  if (error) {
    return genResp.badRequest(error.message)
  }

  return false
}

/**
 * 处理表格请求
 * @param {Context} ctx - 上下文数据，包含请求体、响应生成器和 Lark 服务
 * @returns {Promise<Response>} 返回响应对象
 */
export const manageSheetReq = async (ctx: Context): Promise<Response> => {
  const { body: rawBody, genResp, requestId, db } = ctx
  const body = rawBody as SheetProxy.InsertData

  // 校验参数
  const validateRes = await validateSheetReq(ctx)
  if (validateRes) return validateRes

  // 校验 api_key
  const apiKeyInfo = await db.apiKey.getWithApp(body.api_key)
  if (!apiKeyInfo) {
    return genResp.notFound("api key not found")
  }

  // 获取 app name
  const appName = apiKeyInfo.expand?.app?.name
  if (!appName) {
    return genResp.notFound("app name not found")
  }

  // 获取APP信息
  const appInfo = APP_MAP[appName]
  if (!appInfo) {
    return genResp.notFound("app not found")
  }

  // 组织新的LarkService
  ctx.larkService = new LarkService({
    appId: appInfo.appId,
    appSecret: appInfo.appSecret,
    requestId,
  })

  // 根据请求类型处理
  if (body.type === "insert") return await insertSheet(ctx)

  // 默认返回成功响应
  return genResp.ok()
}