import { config as hardhatConfig, network } from "hardhat";

export type WorkflowMode = "execute" | "simulate" | "verify";

export interface SimulationFork {
  forkRpcUrl?: string;
}

export const resolveWorkflowMode = (
  args: Record<string, string | boolean>,
): WorkflowMode => {
  const mode = typeof args.mode === "string" ? args.mode : "execute";
  if (
    mode !== "execute"
    && mode !== "simulate"
    && mode !== "verify"
  ) {
    throw new Error(`Unsupported workflow mode: ${mode}`);
  }
  return mode;
};

const targetNetworkUrl = (targetId: string): string => {
  const networks = hardhatConfig.networks as Record<string, { url?: string }>;
  const targetNetwork = networks[targetId];
  if (!targetNetwork) {
    throw new Error(`Missing hardhat.config.ts network "${targetId}"`);
  }
  if (!targetNetwork.url) {
    throw new Error(`Network "${targetId}" cannot be forked because it has no url`);
  }
  return targetNetwork.url;
};

export const setupSimulationFork = async (targetId: string): Promise<SimulationFork> => {
  if (network.name !== "hardhat") {
    throw new Error("Simulation mode must run with --network hardhat");
  }
  if (targetId === "hardhat") {
    return {};
  }

  const forkRpcUrl = targetNetworkUrl(targetId);

  await network.provider.request({
    method: "hardhat_reset",
    params: [
      {
        forking: {
          jsonRpcUrl: forkRpcUrl,
        },
      },
    ],
  });

  await network.provider.request({
    method: "hardhat_mine",
    params: ["0x1"],
  });

  return { forkRpcUrl };
};