/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
import { IncomingHttpHeaders, OutgoingHttpHeaders, Server } from 'http'

import { debug } from 'debug'
import { createServer } from 'aws-serverless-express'
import { eventContext } from 'aws-serverless-express/middleware'
import * as express from 'express'
import * as helmet from 'helmet'
import * as rateLimit from 'express-rate-limit'
import { ValidationPipe, Type, Abstract } from '@nestjs/common'
import { ExpressAdapter } from '@nestjs/platform-express'
import { HttpAdapterHost, NestFactory } from '@nestjs/core'

import { AllExceptionsMiddleware, LoggingInterceptor } from '../middlewares'

import { Secrets } from './secrets'

export type CORS = { [key in keyof (IncomingHttpHeaders | OutgoingHttpHeaders)]: string }

async function createApp(expressApp: any, module: any, cors?: CORS): Promise<void> {
  const app = await NestFactory.create(module, new ExpressAdapter(expressApp), {
    logger: console,
  })

  app.useGlobalFilters(new AllExceptionsMiddleware(app.get(HttpAdapterHost).httpAdapter))
  app.useGlobalPipes(new ValidationPipe())
  app.use(eventContext())
  app.use(helmet())
  app.use(
    rateLimit({
      windowMs: 1 * 60 * 1000,
      max: 1000,
    }),
  )

  if (cors) {
    app.enableCors()
    app.use((request: express.Request) => {
      const response = request.res

      Object.keys(cors).forEach(header => response.setHeader(header, cors[header]))

      request.next()
    })
  }

  app.useGlobalInterceptors(new LoggingInterceptor())

  enableDebug(globalThis.secret.debug_level)

  await app.init()
}

async function loadEnvironment(): Promise<void> {
  const secrets = new Secrets()

  await secrets.loadEnvironment()
}

export async function bootstrap(module: any, cors?: CORS): Promise<Server> {
  await loadEnvironment()

  const expressApp = express()

  await createApp(expressApp, module, cors)

  return createServer(expressApp)
}

export async function staticBootstrap<TInput = any>(
  module: any,
  controller: Type<TInput> | Abstract<TInput> | string | symbol,
): Promise<TInput> {
  await loadEnvironment()

  const app = await NestFactory.createApplicationContext(module, {
    logger: console,
  })
  const appController = app.get(controller)

  if (!appController) throw new Error(`Controller "${String(controller)}" not found`)

  return appController
}

function enableDebug(debugLevel: string): void {
  switch (debugLevel) {
    case 'all':
      return debug.enable('*,-follow-redirects')
    case 'request':
      return debug.enable('request:*')
    case 'none':
    default:
      return
  }
}