// proxy.middleware.ts
import {
  Inject,
  NestMiddleware,
} from '@nestjs/common';
import { Request, Response } from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';
import { ConfigurationService } from '../configuration/configuration.service';
import { randomUUID } from 'node:crypto';

export class ProxyMiddleware implements NestMiddleware {
  constructor(
    private configService: ConfigurationService,
  ) {}

  async use(req: Request, res: Response, next: () => void): Promise<any> {
    const upstreamInfo = <method to get jwt etc>;
    const correlationId = randomUUID();

    const proxy = createProxyMiddleware({
      target: this.configService.getProxyTarget(),
      headers: {
        host: this.configService.getUpstreamHost(),
        authorization: `Bearer ${upstreamInfo.jwt}`,
        'x-organization-id': upstreamInfo.organizationId,
        'x-correlation-id': correlationId,
      },
      changeOrigin: false,
      xfwd: true,
    });

    proxy(req, res, next);
  }
}

// proxy.module.ts
import {
  MiddlewareConsumer,
  Module,
  NestModule,
  RequestMethod,
} from '@nestjs/common';
import { ConfigurationModule } from '../configuration/configuration.module';
import { ProxyMiddleware } from './proxy.middleware';

@Module({
  providers: [],
  imports: [
    ConfigurationModule,
  ],
})
export class ProxyModule implements NestModule {
  configure(consumer: MiddlewareConsumer): any {
    consumer
      .apply(ProxyMiddleware)
      .exclude(
        { path: 'ready', method: RequestMethod.GET },
        { path: 'live', method: RequestMethod.GET },
      )
      .forRoutes('');
  }
}

// proxy.middleware.ts
import {
  Inject,
  NestMiddleware,
} from '@nestjs/common';
import { Request, Response } from 'express';
import { RequestHandler, createProxyMiddleware } from 'http-proxy-middleware';
import { ConfigurationService } from '../configuration/configuration.service';
import { randomUUID } from 'node:crypto';

export class ProxyMiddleware implements NestMiddleware {
  private proxy: RequestHandler;

  constructor(
    private configService: ConfigurationService,
  ) {
    this.proxy = createProxyMiddleware({
      target: this.configService.getProxyTarget(),
      headers: {
        host: this.configService.getUpstreamHost(),
      },
      changeOrigin: false,
      xfwd: true,
    });
  }

  async use(req: Request, res: Response, next: () => void): Promise<any> {
    const upstreamInfo = <method to get jwt etc>;
    const correlationId = randomUUID();

    req.headers = {
      ...req.headers,
      authorization: `Bearer ${upstreamInfo.jwt}`,
      'x-organization-id': upstreamInfo.organizationId,
      'x-correlation-id': correlationId,
    }

    this.proxy(req, res, next);
  }
}

import EventEmitter from "events"
EventEmitter.defaultMaxListeners = 20

import express, { Application, NextFunction, Request, Response } from 'express'
import { createProxyMiddleware, Options } from 'http-proxy-middleware'
import cors from 'cors'
import cookieParser from 'cookie-parser'
import setHeaders from 'libs/set-headers'
import { PORT } from 'config/config'
import { ClientRequest, Server } from 'http'
import routes from 'config/routes'
import accessConfig from 'libs/access-config'
import EventEmitter from 'events'

EventEmitter.defaultMaxListeners = 20
const onProxyReq = (proxyRes: ClientRequest, req: Request, res: Response) => {
  // console.log('proxyRes', proxyRes)

  // for(oldKey of proxyRes.headers) {

  // }
}

const middleware = (req: Request, res: Response, next: NextFunction) => {
  // console.log('hey')
  return next();
}

const start = (): Promise<Server> => {
  return new Promise((resolve, reject) => {
    const app: Application = express();
    app.use(cors({
      origin: ['http://localhost:3000', 'http://localhost:3001'],
      credentials: true,
    }))

    app.use(cookieParser())
    app.use(setHeaders)

    routes.slice(0, 13).forEach(({ route, target, pathRewrite, openAccess }) => {
      let rewrite_path: Record<string, string> | undefined = undefined
      // if(pathRewrite){
      //   rewrite_path = Object.entries(pathRewrite).reduce<Record<string, string>>((prev, [key, value]) => {
      //     prev[key] = value ? value : ''
      //     return prev;
      //   }, {})
      // }
      if(pathRewrite) rewrite_path = { [pathRewrite[0]]: pathRewrite[1] }
      
      console.log(`[HPM] Proxy created: ${route} -> ${target}`)
      const proxyMiddleware = createProxyMiddleware({
        target: target,
        pathFilter: route,
        changeOrigin: true,
        pathRewrite: rewrite_path,
        proxyTimeout: 1000 * 60, // 1 minute
        ws: true,

        // logger: console,
        on: {
          proxyReq: onProxyReq,
          open: () => {
            // console.log(`[HPM] Proxy created: ${route} -> ${target}`)
          },
          start: () => {
            console.log(`[HPM] Proxy created: ${route} -> ${target}`)
          },
          
        }
      })
      app.use(accessConfig(openAccess) as (req: Request, res: Response, next: NextFunction) => void, proxyMiddleware)
    })
    

    // process.setMaxListeners(1000)
    const server = app.listen(PORT, () => resolve(server))
  })
}

export { start }