import { RawAddrKeyHash, RawRewardAccount, RawVrfKeyHash, RewardAccount } from "./address";
import { UintInterval } from "./parameterUpdate";

export type RawPoolKeyHash = Buffer; //28
type RawVerificationKeyHash = Buffer;
type RelayTypes =
  | { port?: number; ipv4?: Buffer; ipv6?: Buffer } // SingleHostAddr
  | { port?: number; dnsName: string } // SingleHostName
  | { dnsName: string }; // MultiHostName

type Relay = RelayTypes;

export type PoolParams = [
  operator: RawPoolKeyHash,
  verificationKeyHash: RawVrfKeyHash,
  pledge: number | bigint,
  cost: number | bigint,
  margin: UintInterval,
  rewardAccount: RawRewardAccount,
  poolOwners: Set<RawAddrKeyHash>,
  relays: Relay[],
  poolMetadata: any,
];

function parseRelay(relay: any[]): Relay[] {
  const parsedRelays: Relay[] = [];
  relay.forEach((element) => {
    switch (element[0]) {
      case 0:
        parsedRelays.push({
          port: element[1],
          ipv4: element[2],
          ipv6: element[3],
        });
        break;
      case 1:
        parsedRelays.push({ port: element[1], dnsName: element[2] });
        break;
      case 2:
        parsedRelays.push({ dnsName: element[1] });
        break;
      default:
        throw new Error(`Invalid relay type: ${element[0]}`);
    }
  });
  return parsedRelays;
}

export type RawPoolParams = [
  RawPoolKeyHash,
  RawVerificationKeyHash,
  bigint,
  bigint,
  [number | bigint, number | bigint],
  RawRewardAccount,
  Set<RawAddrKeyHash>,
  any,
  [string, Buffer],
];

export function parsePoolParams(poolParams: any[]) {
  const parsedPoolParams: PoolParams = [
    poolParams[0],
    poolParams[1],
    poolParams[2],
    poolParams[3],
    poolParams[4],
    poolParams[5],
    poolParams[6],
    parseRelay(poolParams[7]),
    poolParams[8],
  ];
  return parsedPoolParams;
}