import { PublicKey, TransactionInstruction, SystemProgram } from "@solana/web3.js";
import { AnchorProvider, Program } from "@coral-xyz/anchor";
import type { Idl } from "@coral-xyz/anchor";
import registryIdl from "./idl/descro_ext_resolvers.json";
import { deriveResolverEntryPda } from "./pda";
import type { ResolverEntry, ResolverEntryWithPda, ResolverType } from "./types";

export class RegistryClient {
  readonly program: Program;
  readonly provider: AnchorProvider;

  constructor(provider: AnchorProvider) {
    this.provider = provider;
    this.program = new Program(registryIdl as Idl, provider);
  }

  async buildRegisterResolver(params: {
    authority: PublicKey;
    resolverType: ResolverType;
    name: string;
    description: string;
    feeBps: number;
    feeRecipient: PublicKey;
    metadataUri: string;
  }): Promise<TransactionInstruction> {
    const { authority, resolverType, name, description, feeBps, feeRecipient, metadataUri } = params;
    const [resolverEntry] = deriveResolverEntryPda(authority);

    return await (this.program.methods as any)
      .registerResolver(resolverType, name, description, feeBps, feeRecipient, metadataUri)
      .accounts({
        authority,
        resolverEntry,
        systemProgram: SystemProgram.programId,
      })
      .instruction();
  }

  async buildUpdateResolver(params: {
    authority: PublicKey;
    name: string;
    description: string;
    feeBps: number;
    metadataUri: string;
  }): Promise<TransactionInstruction> {
    const { authority, name, description, feeBps, metadataUri } = params;
    const [resolverEntry] = deriveResolverEntryPda(authority);

    return await (this.program.methods as any)
      .updateResolver(name, description, feeBps, metadataUri)
      .accounts({
        authority,
        resolverEntry,
      })
      .instruction();
  }

  async fetchResolver(authority: PublicKey): Promise<ResolverEntry | null> {
    try {
      const [pda] = deriveResolverEntryPda(authority);
      const raw = await (this.program.account as any).resolverEntry.fetch(pda);
      return raw as ResolverEntry;
    } catch {
      return null;
    }
  }

  async fetchResolverByPda(pda: PublicKey): Promise<ResolverEntry | null> {
    try {
      const raw = await (this.program.account as any).resolverEntry.fetch(pda);
      return raw as ResolverEntry;
    } catch {
      return null;
    }
  }

  async fetchAllResolvers(): Promise<ResolverEntryWithPda[]> {
    const accounts = await (this.program.account as any).resolverEntry.all();
    return accounts.map((a: { publicKey: PublicKey; account: ResolverEntry }) => ({
      pda: a.publicKey,
      account: a.account as ResolverEntry,
    }));
  }
}