import { ApplicationRouter } from "../../source/services/router";
import { BaseStream } from "../../source/services/stream/base-stream";

export type ControlledRequestDeps = {
  router: ApplicationRouter;
  connection: BaseStream;
}

export type ControlledRequestOptions = {
  path: string;
  requestId: string;
  body?: unknown;
  headers?: Record<string, string>;
  includeAuthHeaders?: boolean;
  timeout?: number;
}

export type ControlledRequestParams = ControlledRequestOptions & ControlledRequestDeps;

export type ControlledRequest = {
  request: Promise<void>;
  started: Promise<void>;
  release: () => void;
}

export const createControlledRequest = ({ router, connection, ...requestOptions }: ControlledRequestParams): ControlledRequest => {
  // Create promises with resolvers to signal the request has started and released
  const { promise: started, resolve: signalStarted } = Promise.withResolvers<void>();
  const { promise: released, resolve: release } = Promise.withResolvers<void>();

  // The request options (sets the includeAuthHeaders to true by default)
  const options = {
    includeAuthHeaders: true,
    ...requestOptions
  }

  // The test auth headers
  const authHeaders = {
    'x-public-key':  'public-key',
    'x-signature': 'signature',
    'x-timestamp': '1000',
  }

  // If the request should include the test auth headers (default is true)
  if (options.includeAuthHeaders) {
    options.headers = {
      ...options.headers,
      ...authHeaders,
    };
  }

  // Add the signalStarted and released promises to the request body
  options.body = {
    ...(options.body ?? {}),
    signalStarted,
    released,
  }

  // Dispatch the request
  const request = router.dispatch(options, connection);
  
  // Return the request, started, and release promises
  return {
    request,
    started,
    release,
  };
};