import * as web3 from "@solana/web3.js";
import { AnchorProvider, BorshAccountsCoder, Program, Provider } from "@project-serum/anchor";
import {
  AccountData,
  ExtendedAccountData,
  ExtendedQuestEntryData,
  ExtendedQuestPoolData,
  QuestEntryData,
  QuestPoolData,
  QUEST_POOL_IDL,
  QUEST_POOL_PROGRAM,
  QUEST_POOL_PROGRAM_ID,
  STAKER_OFFSET,
} from "./constants";
import { findExtendedQuestEntryId, findExtendedQuestPoolId } from "./pda";

export const getAllQuestEntries = async (
  connection: web3.Connection,
  user?: web3.PublicKey | null
): Promise<ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[]> => {
  const programAccounts = await connection.getProgramAccounts(
    QUEST_POOL_PROGRAM_ID,
    user
      ? {
          filters: [
            { memcmp: { offset: STAKER_OFFSET, bytes: user.toBase58() } },
          ],
        }
      : {}
  );
  const questEntryDatas: ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[] = [];
  const coder = new BorshAccountsCoder(QUEST_POOL_IDL);
  for(let i = 0; i < programAccounts.length; i++){
    const account = programAccounts[i];
    try {
      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
      const questEntryData: QuestEntryData = coder.decode(
        "stakeEntry",
        account.account.data
      );
      if (
        questEntryData &&
        questEntryData.staker.toString() != web3.PublicKey.default.toBase58()
      ) {
        questEntryDatas.push({
          ...account,
          parsed: questEntryData,
          extended: null
        });
      }
    } catch (e) {
      // console.log(`Failed to decode token manager data`);
    }
  }
  return questEntryDatas.sort((a, b) =>
    a.pubkey.toBase58().localeCompare(b.pubkey.toBase58())
  );
};

export const getQuestPools = async (
  connection: web3.Connection,
  questPoolIds: web3.PublicKey[]
): Promise<ExtendedAccountData<QuestPoolData, ExtendedQuestPoolData>[]> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );

  let questPools = [];
  try {
    questPools = await stakePoolProgram.account.stakePool.fetchMultiple(
      questPoolIds
    );
  } catch (e) {
    console.log(e);
  }

  questPools =  questPools.map((tm, i) => ({
    parsed: tm,
    pubkey: questPoolIds[i],
    extended: null
  }));
  questPools = await addExtendedQuestPools(connection, questPools);
  return questPools
};

export const getAllQuestPools = async (
  connection: web3.Connection
): Promise<ExtendedAccountData<QuestPoolData, ExtendedQuestPoolData>[]> => {
  const programAccounts = await connection.getProgramAccounts(
    QUEST_POOL_PROGRAM_ID
  );

  const questPools: ExtendedAccountData<QuestPoolData, ExtendedQuestPoolData>[] = [];
  const coder = new BorshAccountsCoder(QUEST_POOL_IDL);
  for(let i = 0; i < programAccounts.length; i++){
    const account = programAccounts[i];
    try {
      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
      const questPoolData: QuestPoolData = coder.decode(
        "stakePool",
        account.account.data
      );
      if (questPoolData) {
        questPools.push({
          ...account,
          parsed: questPoolData,
          extended: null
        });
      }
    } catch (e) {
      // console.log(`Failed to decode token manager data`);
    }
  };

  const result = await addExtendedQuestPools(connection, questPools);

  return result.sort((a, b) =>
    a.pubkey.toBase58().localeCompare(b.pubkey.toBase58())
  );
};

export const getQuestEntries = async (
  connection: web3.Connection,
  questEntryIds: web3.PublicKey[]
): Promise<ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[]> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );

  let stakeEntries = [];
  try {
    stakeEntries = await stakePoolProgram.account.stakeEntry.fetchMultiple(
      questEntryIds
    );
  } catch (e) {
    console.log(e);
  }

  stakeEntries = stakeEntries.map((tm, i) => ({
    parsed: tm,
    pubkey: questEntryIds[i],
    extended: null
  }));

  return stakeEntries;
};

export const getQuestEntriesByPool = async (
  connection: web3.Connection,
  questEntryIds: web3.PublicKey[],
  questPoolId: web3.PublicKey
): Promise<ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[]> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );

  let stakeEntries = [];
  try {
    stakeEntries = await stakePoolProgram.account.stakeEntry.fetchMultiple(
      questEntryIds
    );
  } catch (e) {
    console.log(e);
  }

  stakeEntries = stakeEntries.map((tm, i) => ({
    parsed: tm,
    pubkey: questEntryIds[i],
    extended: null
  }));

  stakeEntries = await addExtendedQuestEntries(connection, stakeEntries, questPoolId);
  return stakeEntries;
};

export const getQuestEntriesForUser = async (
  connection: web3.Connection,
  user: web3.PublicKey
): Promise<ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[]> => {
  const programAccounts = await connection.getProgramAccounts(
    QUEST_POOL_PROGRAM_ID,
    {
      filters: [{ memcmp: { offset: STAKER_OFFSET, bytes: user.toBase58() } }],
    }
  );
  const questEntryDatas: ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[] = [];
  const coder = new BorshAccountsCoder(QUEST_POOL_IDL);
  for(let i = 0; i < programAccounts.length; i++){
    const account = programAccounts[i];
    try {
      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
      const questEntryData: QuestEntryData = coder.decode(
        "stakeEntry",
        account.account.data
      );
      if (
        questEntryData
      ) {
        questEntryDatas.push({
          ...account,
          parsed: questEntryData,
          extended: null
        });
      }
    } catch (e) {
      // console.log(`Failed to decode token manager data`);
    }
  }


  return questEntryDatas.sort((a, b) =>
    a.pubkey.toBase58().localeCompare(b.pubkey.toBase58())
  );
};

export const getExtendedQuestPool = async (
  connection: web3.Connection,
  questPoolId: web3.PublicKey
): Promise<AccountData<ExtendedQuestPoolData>> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );
  const [extendedQuestPoolId] = await findExtendedQuestPoolId(questPoolId);
  const extendedQuestPool = await stakePoolProgram.account.extendedStakePool.fetchNullable(
    extendedQuestPoolId
  );
  return {
    parsed: extendedQuestPool,
    pubkey: extendedQuestPoolId,
  };
};


export const getExtendedQuestEntry = async (
  connection: web3.Connection,
  questEntryId: web3.PublicKey,
  questPoolId: web3.PublicKey
): Promise<AccountData<ExtendedQuestEntryData>> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );
  const [extendedQuestEntryId] = findExtendedQuestEntryId(questEntryId, questPoolId);
  const extendedQuestEntry = await stakePoolProgram.account.extendedStakeEntry.fetchNullable(
    extendedQuestEntryId
  );
  return {
    parsed: extendedQuestEntry,
    pubkey: extendedQuestEntryId,
  };
};

export const addExtendedQuestPools = async (
  connection: web3.Connection,
  questPools: ExtendedAccountData<QuestPoolData, ExtendedQuestPoolData>[]
): Promise<ExtendedAccountData<QuestPoolData, ExtendedQuestPoolData>[]> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );
  const extendedQuestPoolIds = [];
  questPools.forEach((val)=>{
    const [extendedQuestPoolId] = findExtendedQuestPoolId(val.pubkey);
    extendedQuestPoolIds.push(extendedQuestPoolId)
  })
  
  const extendedQuestPools = await stakePoolProgram.account.extendedStakePool.fetchMultiple(
    extendedQuestPoolIds
  ) as any[];
  return questPools.map((tm, i) => ({
    ...tm,
    extended: {
      pubkey: extendedQuestPoolIds[i],
      parsed: extendedQuestPools[i]
    }
  }));
}

export const addExtendedQuestEntries = async (
  connection: web3.Connection,
  questEntries: ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[],
  questPoolId: web3.PublicKey
): Promise<ExtendedAccountData<QuestEntryData, ExtendedQuestEntryData>[]> => {
  const provider = new AnchorProvider(connection, null, {});
  const stakePoolProgram = new Program<QUEST_POOL_PROGRAM>(
    QUEST_POOL_IDL,
    QUEST_POOL_PROGRAM_ID,
    provider
  );
  const extendedQuestEntryIds = [];
  questEntries.forEach((val)=>{
    const [extendedQuestEntryId] = findExtendedQuestEntryId(val.pubkey, questPoolId);
    extendedQuestEntryIds.push(extendedQuestEntryId)
  })
  
  const extendedQuestEntries = await stakePoolProgram.account.extendedStakeEntry.fetchMultiple(
    extendedQuestEntryIds
  ) as any[];
  return questEntries.map((tm, i) => ({
    ...tm,
    extended: {
      pubkey: extendedQuestEntryIds[i],
      parsed: extendedQuestEntries[i]
    }
  }));
}