import type { ArgumentsHost, ExecutionContext } from '@nestjs/common';
import { AsyncContextStorage } from '@rsdk/actx/dist/async-context.storage'; // TODO: исправить после влития PR по ACTX

import { InternalException, ProtocolDetector } from '../../src';
import { DEFAULT_TRACING_HEADERS } from '../../src/tracing/constants';
import { TracingInterceptor } from '../../src/tracing/tracing.interceptor';
import type {
  GenericHeaders,
  WithGenericHeaders,
} from '../../src/types/transports';

interface Input {
  type: string;
  headerKey: string;
}

export class LoggerMock {
  trace(): void {}
}

const extractHeaders = (ctx: ExecutionContext): GenericHeaders => ({
  get: (key: string) => ctx.getArgByIndex(0).headers[key],
});

const transport = {
  extractHeaders,
  getProtocol: (): string => 'some-transport-protocol',
  matchByContext: (ctx: ArgumentsHost): boolean => ctx.getType() === 'http',
} as any;

const plugin = {
  tracingHeadersExtractors: (): {
    protocol: string;
    extractor: WithGenericHeaders;
  }[] => [
    {
      protocol: 'some-plugin-protocol',
      extractor: { extractHeaders },
    },
  ],
} as any;

const tracingInterceptor = new TracingInterceptor(
  new LoggerMock() as any,
  new Set([transport]),
  new Set([plugin]),
  DEFAULT_TRACING_HEADERS,
  new ProtocolDetector([transport]),
);

const callHandler = {
  handle: () => {},
} as any;

export async function fuzz(buffer: Buffer): Promise<any> {
  try {
    const input = parseInput(buffer);
    if (!input) return;

    const ctx: any = {
      getType: () => input.type,
      getArgByIndex: (_: number) => ({
        headers: { [input.headerKey]: 'some-value' },
      }),
    };

    AsyncContextStorage.run(new Map(), () => {
      tracingInterceptor.intercept(ctx, callHandler as any);
    });
  } catch (error) {
    if (error instanceof InternalException) return;

    throw error;
  }

  function parseInput(buffer: Buffer): Input | null {
    let input: any;

    try {
      input = JSON.parse(buffer.toString());
    } catch {
      return null;
    }

    if (typeof input !== 'object' || input === null) return null;
    if (typeof input.type !== 'string') return null;
    if (typeof input.headerKey !== 'string') return null;

    return input;
  }
}