// 官方文档示例
import cloud from '@lafjs/cloud'
const db = cloud.mongo.db
 
export default async function () {
  const ret = await db.collection('users').insertOne({ 
    name: '王小波',
    age: 44,
    books: ['黄金时代', '白银时代', '青铜时代']
  })
 
  console.log(ret)
}

// 官方文档示例
import cloud from '@lafjs/cloud'
 
export default async function (ctx: FunctionContext) {
  // 获取存储桶
  const bucket = cloud.storage.bucket('data')
 
  // 写文件，假设是一个大文件
  const content = 'hello, laf'
  await bucket.writeFile('laf.html', content)
}

import cloud from '@lafjs/cloud'
 
export default async function (ctx: FunctionContext) {
  console.log('Hello World')
  return { data: 'hi, laf' }
}

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/support/cloud-sdk.ts
/**
 * Create a new Cloud SDK instance
 *
 * @returns
 */
export function createCloudSdk() {
  const cloud: CloudSdkInterface = {
    database: () => getDb(DatabaseAgent.accessor),
    invoke: invokeInFunction,
    shared: _shared_preference,
    getToken: getToken,
    parseToken: parseToken,
    mongo: {
      client: DatabaseAgent.client as any,
      db: DatabaseAgent.db as any,
    },
    sockets: WebSocketAgent.clients,
    appid: Config.APPID,
    get env() {
      return process.env
    },
    storage: null,
  }
 
  /**
   * Ensure the database is connected, update its Mongo object, otherwise it is null
   */
  DatabaseAgent.ready.then(() => {
    cloud.mongo.client = DatabaseAgent.client as any
    cloud.mongo.db = DatabaseAgent.accessor.db as any
  })
  return cloud
}

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/support/cloud-sdk.ts
async function invokeInFunction(name: string, ctx?: FunctionContext) {
  const mod = FunctionModule.get(name)
  const func = mod?.default || mod?.main
 
  if (!func) {
    throw new Error(`invoke() failed to get function: ${name}`)
  }
 
  ctx = ctx ?? ({} as any)
  ctx.__function_name = name
 
  ctx.requestId = ctx.requestId ?? 'invoke'
 
  ctx.method = ctx.method ?? 'call'
 
  return await func(ctx)
}

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/init.ts
/**
 * Install packages
 * @param packages
 * @returns
 */
export function installPackages() {
  const deps = process.env.DEPENDENCIES
  if (!deps) {
    return
  }
 
  const flags = Config.NPM_INSTALL_FLAGS
  logger.info('run command: ', `npm install ${deps} ${flags}`)
  const r = execSync(`npm install ${deps} ${flags}`)
  console.log(r.toString())
}

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/support/engine/module.ts
import * as vm from 'vm'
 
export class FunctionModule {
  protected static cache: Map<string, any> = new Map()
 
  private static customRequire = createRequire(
    CUSTOM_DEPENDENCY_NODE_MODULES_PATH,
  )
 
  static get(functionName: string): any {
    const moduleName = `@/${functionName}`
    return this.require(moduleName, [])
  }
 
  static require(moduleName: string, fromModule: string[], filename = ''): any {
      // 加载依赖的逻辑，处理缓存、循环引用等
      // #1 平台封装的sdk
      // #2 云函数
      // #3 其他模块
  }
  /**
   * Compile function module
   */
  static compile(){
    ...
    // #1 包装代码
    const wrapped = this.wrap(code)
    // #2 创建全局对象上下文
    const sandbox = this.buildSandbox(
      functionName,
      fromModules,
      consoleInstance,
    )
    // #3 通过vm创建script脚本
    const script = this.createScript(wrapped, {})
    // #4 在沙箱内执行脚本，返回对应模块
    return script.runInNewContext(sandbox, options)
  }
 
  static deleteCache(): void {
    FunctionModule.cache.clear()
  }
 
  protected static wrap(code: string): string {
    return `
    const require = (name) => {
      __from_modules.push(__filename)
      return __require(name, __from_modules, __filename)
    }
 
    ${code}
    module.exports;
    `
  }
 
  /**
   * Create vm.Script
   */
  protected static createScript(){
    const script = new vm.Script(code, _options)
    return script
  }
 
  /**
   * Build function module global sandbox
   */
  protected static buildSandbox(){
    const sandbox: FunctionModuleGlobalContext = {
      __filename: functionName,
      module: _module,
      exports: _module.exports,
      console: fConsole,
      __require: this.require.bind(this),
      Buffer: Buffer,
      setImmediate: setImmediate,
      clearImmediate: clearImmediate,
      Float32Array: Float32Array,
      setInterval: setInterval,
      clearInterval: clearInterval,
      setTimeout: setTimeout,
      clearTimeout: clearTimeout,
      process: process,
      URL: URL,
      fetch: globalThis.fetch,
      global: null,
      __from_modules: [...__from_modules],
      ObjectId: ObjectId,
    }
    sandbox.global = sandbox
    return sandbox
}

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/handler/router.ts
import { Router } from 'express'
export const router = Router();
/**
 * Invoke cloud function through HTTP request.
 * @method *
 */
// router.all('/:name', uploader.any(), handleInvokeFunction)
router.all('*', uploader.any(), (req, res) => {
  let func_name = req.path
 
  // remove the leading slash
  if (func_name.startsWith('/')) {
    func_name = func_name.slice(1)
  }
 
  // check length
  if (func_name.length > 256) {
    return res.status(500).send('function name is too long')
  }
 
  req.params['name'] = func_name
  handleInvokeFunction(req, res)
})

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/handler/invoke.ts
export async function handleInvokeFunction(req: IRequest, res: Response) {
  const name = req.params?.name
 
  const ctx: FunctionContext = {
    __function_name: name,
    requestId: req.requestId,
    query: req.query,
    files: req.files as any,
    body: req.body,
    headers: req.headers,
    method: req.method,
    auth: req['auth'],
    user: req.user,
    request: req,
    response: res,
  }
 
   ...
  return await invokeFunction(ctx, useInterceptor)
}
 
async function invokeFunction() {
  const name = ctx.__function_name
 
  // 获取函数
  let func = FunctionCache.get(name)
  if (!func) {
    func = FunctionCache.get(DEFAULT_FUNCTION_NAME)
    if (!func) {
      return ctx.response.status(404).send('Function Not Found')
    }
  }
 
  try {
    const executor = new FunctionExecutor(func)
    const result = await executor.invoke(ctx, useInterceptor)
 
    if (result.error) {
      logger.error(result.error)
      return ctx.response.status(500).send({
        error: 'Internal Server Error',
        requestId,
      })
    }
}
 
 

// https://github.com/labring/laf/blob/main/runtimes/nodejs/src/support/engine/executor.ts
 
export class FunctionExecutor {
  async invoke(){
    try {
      const mod = this.getModule()
      const main = mod.default || mod.main
      // 执行函数
      data = await main(context)
      return {
        data,
        time_usage: timeUsage,
      }
    } catch (error) {
 
      return {
        error,
        time_usage: timeUsage,
      }
    }
  }