import {
  AnchorProvider,
  BorshAccountsCoder,
  Program,
  utils,
} from "@coral-xyz/anchor";
import { SignerWallet } from "@saberhq/solana-contrib";
import type {
  AccountInfo,
  Commitment,
  Connection,
  PublicKey,
} from "@solana/web3.js";
import { Keypair } from "@solana/web3.js";

import { AccountData } from "../../types";
import type { PROJECT_PROGRAM, ProjectData } from "./constants";
import { PROJECT_ADDRESS, PROJECT_IDL, PROJECT_PREFIX } from "./constants";

const getProgram = (
  connection: Connection,
  commitment: Commitment = "processed"
) => {
  const provider = new AnchorProvider(
    connection,
    new SignerWallet(Keypair.generate()),
    {
      commitment,
    }
  );
  return new Program(PROJECT_IDL as PROJECT_PROGRAM, provider);
};

export const getProject = async (
  connection: Connection,
  projectId: PublicKey,
  commitment?: Commitment
) => {
  const program = getProgram(connection, commitment);

  const parsed = await program.account.project.fetch(projectId);
  return {
    parsed,
    pubkey: projectId,
  };
};

export const getProjects = async (
  connection: Connection,
  projectIds: PublicKey[],
  commitment?: Commitment
) => {
  const program = getProgram(connection, commitment);
  const projects = await program.account.project.fetchMultiple(projectIds);
  return projects.map((tm, i) => ({
    parsed: tm,
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    pubkey: projectIds[i]!,
  }));
};

export const getAllProjects = async (
  connection: Connection,
  commitment?: Commitment
): Promise<AccountData<ProjectData>[]> => {
  if (!connection) return [];
  const programAccounts = await connection.getProgramAccounts(PROJECT_ADDRESS, {
    filters: [
      {
        memcmp: {
          offset: 0,
          bytes: utils.bytes.bs58.encode(
            new BorshAccountsCoder(
              PROJECT_IDL as PROJECT_PROGRAM
            ).accountDiscriminator(PROJECT_PREFIX)
          ),
        },
      },
    ],
    commitment,
  });
  const projectDatas: Array<{
    account: AccountInfo<Buffer>;
    pubkey: PublicKey;
    parsed: ProjectData;
  }> = [];
  const coder = new BorshAccountsCoder(PROJECT_IDL as PROJECT_PROGRAM);
  programAccounts.forEach((account) => {
    try {
      const projectData = coder.decode(PROJECT_PREFIX, account.account.data);
      if (projectData) {
        projectDatas.push({
          ...account,
          parsed: projectData,
        });
      }
      // eslint-disable-next-line no-empty
    } catch (e) {}
  });
  return projectDatas.sort((a, b) =>
    a.pubkey.toBase58().localeCompare(b.pubkey.toBase58())
  );
};

export const getIdentifier = async (
  connection: Connection,
  identifierId: PublicKey,
  commitment?: Commitment
) => {
  const program = getProgram(connection, commitment);
  const parsed = await program.account.identifier.fetch(identifierId);
  return {
    parsed,
    pubkey: identifierId,
  };
};