import {
  NestInterceptor,
  ExecutionContext,
  CallHandler,
  HttpStatus,
  Injectable,
  Inject,
  Optional,
  Logger
} from "@nestjs/common";
import { Reflector } from "@nestjs/core";
import { Request, Response } from "express";
import { Observable, throwError } from "rxjs";
import { catchError, tap } from "rxjs/operators";

@Injectable()
export class HTTPInterceptor implements NestInterceptor {
  private readonly logger = new Logger(HTTPInterceptor.name);
  private readonly noiseCache = new Map<string, string>();

  constructor(@Optional() @Inject(Reflector) private readonly reflector?: Reflector) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const startTime = Date.now();

    const skip = this.reflector
      ? this.reflector.getAllAndOverride<boolean>("skip-request-interceptor", [
          context.getHandler(),
          context.getClass()
        ])
      : false;

    const skipNoise = this.reflector
      ? this.reflector.getAllAndOverride<boolean>("skip-noise-interceptor", [
          context.getHandler(),
          context.getClass()
        ])
      : false;

    const http = context.switchToHttp();
    const req: Request = http.getRequest();
    const res: Response = http.getResponse();

    return next.handle().pipe(
      tap(() => {
        if (skip) return;
        const duration = Date.now() - startTime;
        const statusCodeColor = this.getStatusCodeColor(res.statusCode);
        const logLine = `\x1b[34m${req.method}\x1b[0m ${req.url} ${statusCodeColor || "-"} ${duration}ms`;

        if (skipNoise) {
          const key = `${req.method}:${req.url}`;
          const sig = `${res.statusCode}`;
          if (this.noiseCache.get(key) === sig) return;
          this.noiseCache.set(key, sig);
        }

        this.logger.log(logLine);
      }),
      catchError(error => {
        if (!error.status || error.status >= 500) console.error(error);

        const duration = Date.now() - startTime;
        const statusCode = error.status || error.statusCode || HttpStatus.INTERNAL_SERVER_ERROR;
        const statusCodeColor = this.getStatusCodeColor(statusCode);
        let message = error.message || error;
        if (error.response?.message) {
          if (typeof error.response.message === "string") message = error.response.message;
          else message = error.response.message.join(", ");
        }

        this.logger.error(
          `\x1b[34m${req.method}\x1b[0m ${req.url} ${statusCodeColor || "-"} ${
            res.getHeader("content-length") || "-"
          } ${duration}ms \x1b[33m${message}\x1b[0m`
        );
        return throwError(() => error);
      })
    );
  }

  /**
   * Returns an ANSI color-coded string for the given HTTP status code.
   *
   * Colors:
   * - Green (2xx): Successful responses
   * - Blue (3xx): Redirections
   * - Yellow (4xx): Client errors
   * - Red (5xx): Server errors
   *
   * @param {number} statusCode - HTTP response status code.
   * @returns {string} Color-coded status code string.
   */
  private getStatusCodeColor(statusCode: number): string {
    if (statusCode >= 200 && statusCode < 300) {
      return `\x1b[32m${statusCode}\x1b[0m`; // Green for 2xx
    } else if (statusCode >= 300 && statusCode < 400) {
      return `\x1b[34m${statusCode}\x1b[0m`; // Blue for 3xx
    } else if (statusCode >= 400 && statusCode < 500) {
      return `\x1b[33m${statusCode}\x1b[0m`; // Yellow for 4xx
    } else if (statusCode >= 500) {
      return `\x1b[31m${statusCode}\x1b[0m`; // Red for 5xx
    } else {
      return `${statusCode}`; // Default no color
    }
  }
}