import {
  Config,
  GroupConfig,
  I80F48,
  IDL,
  IDS,
  PerpEventLayout,
  PerpMarketConfig,
} from "@blockworks-foundation/mango-client";
import { Coder } from "@project-serum/anchor";
import { getLatestObjPerCombination } from './utils';

// Unfortunately ids.json does not correspond to the token indexes in the log - so keep a map here for reference
// mango group -> token index -> mint key
// TODO: is there a better way?
var tokenIndexesMap = {
    '98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
      0: 'MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac',
      1: '9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E',
      2: '2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk',
      3: 'So11111111111111111111111111111111111111112',
      4: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
      5: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
      6: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
      7: '8HGyAAB1yoM1ttS7pXjHMa3dukTFGQggnFFH3hJZgzQh',
      8: 'AGFEad2et2ZJif9jaGpdMixQqvW5i81aBdvKe7PHNfz3',
      10:'mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So',
      11: '9gP2kCy3wA1ctvYWQk75guqXuHfrEomqydHLtcTCqiLa',
      12: 'KgV1GvrHQmRBY8sHQQeUKwTm2r2h8t4C8qt12Cw1HVE',
      13: 'F6v4wfAdJB8D8p77bMXZgYt8TDKsYxLYxH5AFhUkYx9W',
      15: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
    },
    '4yJ2Vx3kZnmHTNCrHzdoj5nCwriF2kVhfKNvqC6gU8tr': {
      0: 'MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac',
      1: '9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E',
      2: '2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk',
      3: 'So11111111111111111111111111111111111111112',
      4: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
      5: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
      15: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
    },
  };
  
  // mango group -> token index -> mint key
  var oracleIndexesMap = {
    '98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
      0: '49cnp1ejyvQi3CJw3kKXNCDGnNbWDuZd3UG3Y2zGvQkX',
      1: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
      2: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
      3: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
      4: '3vxLXJqLqF3JG5TCbYycbKWRBbCJQLxQmBGCkyqEEefL',
      5: '3NBReDRTLKMQEKiLD5tGcx4kXbTf88b7f2xLS9UuGjym',
      6: 'AnLf8tVYCM816gmBjiy8n53eXKKEDydT5piYjjQDPgTB',
      7: '9xYBiDWYsh2fHzpsz3aaCnNHCKWBNtfEDLtU6kS4aFD9',
      8: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
      9: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
      10:'E4v1BBgoso9s64TQvmyownAVJbhbEPGyzA3qn4n46qj9',
      11: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
      12: 'C2GXZT21UUm6G3J4N26h6d3tpgfUhh6ok5aNi24K88Wu',
      13: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY'
    },
    '4yJ2Vx3kZnmHTNCrHzdoj5nCwriF2kVhfKNvqC6gU8tr': {
      0: '49cnp1ejyvQi3CJw3kKXNCDGnNbWDuZd3UG3Y2zGvQkX',
      1: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
      2: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
      3: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
      4: '3NBReDRTLKMQEKiLD5tGcx4kXbTf88b7f2xLS9UuGjym',
      5: '3vxLXJqLqF3JG5TCbYycbKWRBbCJQLxQmBGCkyqEEefL',
    },
  };

  // Lot sizes also not available on ids.json
  // mango group -> perp name -> lot sizes
  var perpLotSizes = {
    '98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
      'MNGO-PERP': {
        'pk': '4nfmQP3KmUqEJ6qJLsS3offKgE96YUB4Rp7UQvm2Fbi9',
        'baseLotSize': 1000000,
        'quoteLotSize': 100
      },
      'BTC-PERP': {
        'pk': 'DtEcjPLyD4YtTBB4q8xwFZ9q49W89xZCZtJyrGebi5t8',
        'baseLotSize': 100,
        'quoteLotSize': 10
      },
      'ETH-PERP': {
        'pk': 'DVXWg6mfwFvHQbGyaHke4h3LE9pSkgbooDSDgA4JBC8d',
        'baseLotSize': 1000,
        'quoteLotSize': 100
      },
      'SOL-PERP': {
        'pk': '2TgaaVoHgnSeEtXvWTx13zQeTf4hYWAMEiMQdcG6EwHi',
        'baseLotSize': 10000000,
        'quoteLotSize': 100
      },
      'SRM-PERP': {
        'pk': '4GkJj2znAr2pE2PBbak66E12zjCs2jkmeafiJwDVM9Au',
        'baseLotSize': 100000,
        'quoteLotSize': 100
      },
      'RAY-PERP': {
        'pk': '6WGoQr5mJAEpYCdX6qjju2vEnJuD7e8ZeYes7X7Shi7E',
        'baseLotSize': 100000,
        'quoteLotSize': 100
      },
      'FTT-PERP': {
        'pk': 'AhgEayEGNw46ALHuC5ASsKyfsJzAm5JY8DWqpGMQhcGC',
        'baseLotSize': 100000,
        'quoteLotSize': 100
      },
      'ADA-PERP': {
        'pk': 'Bh9UENAncoTEwE7NDim8CdeM1GPvw6xAT4Sih2rKVmWB',
        'baseLotSize': 1000000,
        'quoteLotSize': 100
      },
      'BNB-PERP': {
        'pk': 'CqxX2QupYiYafBSbA519j4vRVxxecidbh2zwX66Lmqem',
        'baseLotSize': 100000,
        'quoteLotSize': 100
      },
      'AVAX-PERP': {
        'pk': 'EAC7jtzsoQwCbXj1M3DapWrNLnc3MBwXAarvWDPr2ZV9',
        'baseLotSize': 1000000,
        'quoteLotSize': 100
      },
      'LUNA-PERP': {
        'pk': 'BCJrpvsB2BJtqiDgKVC4N6gyX1y24Jz96C6wMraYmXss',
        'baseLotSize': 10000,
        'quoteLotSize': 100
      }
    }
  }

var ids = IDS;

export function anchorParser(parsedTransactions, result, signature, blockTime, slot, blockDatetime) {
    
    let serializedLogMessages: any = [];
    const coder = new Coder(IDL);

    if (result.meta.logMessages.includes('Log truncated')) {
      throw new Error("Log truncated");
    }

    for (let i = 0; i < result.meta.logMessages.length; i++) {
        const logMessage = result.meta.logMessages[i];
        const jsonStartStr = "Program log: mango-log";

        if (logMessage.startsWith(jsonStartStr)) {
        const serializedMangoLog = result.meta.logMessages[i + 1].slice(
            "Program log: ".length
        );
        serializedLogMessages.push(serializedMangoLog);
        }
    }

    // Can have multiple inserts per signature so add instructionNum column to allow a primary key
    let eventNum = 1;

    let allNetBalances: any = [];
    for (const log of serializedLogMessages) {
        const decodedEvent = coder.events.decode(log);
        const eventName = decodedEvent?.name;
        const eventData = decodedEvent?.data as any;

        if (eventName === "CachePricesLog") {
        parsedTransactions.cache_prices.push(
            ...parseCachePrices(
            eventNum,
            eventData,
            signature,
            blockTime,
            slot,
            blockDatetime
            )
        );
        } else if (eventName === "CacheRootBanksLog") {
          parsedTransactions.cache_indexes.push(
              ...parseCacheRootBanks(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "DepositLog" || eventName === "WithdrawLog") {
          parsedTransactions.deposits_withdraws.push(
              parseDepositWithDraw(
              eventNum,
              eventData,
              eventName,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "TokenBalanceLog") {
          // Net balances is a special case - we only want to keep the latest change to net balance for each
          // (mangoAccount, symbol) pair in each transaction
          allNetBalances.push(
              parseTokenBalance(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "RedeemMngoLog") {
          parsedTransactions.redeem_mngo.push(
              parseRedeemMngo(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "FillLog") {
          parsedTransactions.fill_events.push(
              parseFillLog(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "LiquidateTokenAndTokenLog") {
          parsedTransactions.liquidate_token_and_token.push(
              parseLiquidateTokenAndToken(
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "LiquidateTokenAndPerpLog") {
          parsedTransactions.liquidate_token_and_perp.push(
              parseLiquidateTokenAndPerp(
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "LiquidatePerpMarketLog") {
          parsedTransactions.liquidate_perp_market.push(
              parseLiquidatePerpMarket(
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "TokenBankruptcyLog") {
          parsedTransactions.token_bankruptcy.push(
              parseTokenBankruptcy(
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "PerpBankruptcyLog") {
          const [perpBankruptcyRow, updateFundingRow] = parsePerpBankruptcy(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
          );
          parsedTransactions.perp_bankruptcy.push(perpBankruptcyRow);
          parsedTransactions.funding.push(updateFundingRow);
        } else if (eventName === "SettlePnlLog") {
          parsedTransactions.settle_pnl.push(
              ...parseSettlePnl(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "SettleFeesLog") {
          parsedTransactions.settle_fees.push(
              parseSettleFees(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "UpdateFundingLog") {
          parsedTransactions.funding.push(
              parseUpdateFunding(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          );
        } else if (eventName === "UpdateRootBankLog") {
          parsedTransactions.cache_indexes.push(
            parseUpdateRootBank(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
            )
        } else if (eventName === "CachePerpMarketsLog") {
          // pass - logging from CachePerpMarkets is redundant - can just log from updateFunding

          // parsedTransactions.funding.push(
          //   ...parseCachePerpMarkets(
          //     eventNum,
          //     eventData,
          //     signature,
          //     blockTime,
          //     slot,
          //     blockDatetime
          //     )
          // )
        } else if (eventName === "OpenOrdersBalanceLog") {
          parsedTransactions.open_orders_balances.push(
            parseOpenOrdersBalance(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          )
        } else if (eventName === "MngoAccrualLog") {
          parsedTransactions.mango_accrual.push(
            parseMngoAccrual(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
          )
        } else if (eventName === "CancelAllPerpOrdersLog") {
          parsedTransactions.cancel_all_perp_orders.push(
            ...parseCancelAllPerpOrders(
              eventNum,
              eventData,
              signature,
              blockTime,
              slot,
              blockDatetime
              )
            );
        } 
        else {
          throw new Error("Unknown anchor event: " + eventName);
        }
        
        eventNum++;
    }

    // Extract the latest (mangoAccount, symbol) pair from net balances changes in the transaction
    parsedTransactions.net_balances.push(...getLatestObjPerCombination(allNetBalances, ['mango_account','symbol']))

}

function parseMngoAccrual(
  instructionNum,
  eventData,
  signature,
  blockTime,
  slot,
  blockDatetime
  ) {

  const config = new Config(IDS);

  const groupConfig = config.groups.find((g) =>
    g.publicKey.equals(eventData.mangoGroup)
  ) as GroupConfig;

  let perpMarketConfig = groupConfig.perpMarkets.find(
    (p) => p.marketIndex === eventData.marketIndex.toNumber()
  ) as PerpMarketConfig;

  let mangoDecimals = groupConfig.tokens.find((e) => e["symbol"] === 'MNGO')!.decimals
  let mangoAccrualUi = eventData.mngoAccrual.toNumber() / Math.pow(10, mangoDecimals)

  return {
    margin_account: eventData.mangoAccount.toString(),
    perp_market: perpMarketConfig.name,
    base_symbol: perpMarketConfig.baseSymbol,
    mango_accrual: mangoAccrualUi,
    
    instruction_num: instructionNum,
    mango_group: eventData.mangoGroup.toString(),
    block_datetime: blockDatetime,
    slot: slot,
    signature: signature,
    blocktime: blockTime,
  }

}

function parseOpenOrdersBalance(
  instructionNum,
  eventData,
  signature,
  blockTime,
  slot,
  blockDatetime
) {

  let mangoGroup = eventData.mangoGroup.toString()
  let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroup)[
    "tokens"
  ];

  let tokenIndex = eventData.marketIndex.toNumber()
  let tokenPk = tokenIndexesMap[mangoGroup][tokenIndex];
  let token = tokens.find((e) => e["mintKey"] === tokenPk);
  let symbol = token.symbol;

  let baseDecimals = token.decimals
  // Assuming that quote currency is always USDC
  let quoteDecimals = tokens.find((e) => e.symbol === 'USDC').decimals;

  let baseFree = eventData.baseFree.toNumber() / Math.pow(10, baseDecimals)
  let baseTotal = eventData.baseTotal.toNumber() / Math.pow(10, baseDecimals)
  let quoteFree = eventData.quoteFree.toNumber() / Math.pow(10, quoteDecimals)
  let quoteTotal = eventData.quoteTotal.toNumber() / Math.pow(10, quoteDecimals)
  let referrerRebatesAccrued = eventData.referrerRebatesAccrued.toNumber() / Math.pow(10, quoteDecimals)
  let marginAccount = eventData.mangoAccount.toString()

  return {
    margin_account: marginAccount,
    symbol: symbol,
    base_free: baseFree,
    base_total: baseTotal,
    quote_free: quoteFree,
    quote_total: quoteTotal,
    referrer_rebates_accrued: referrerRebatesAccrued,
    instruction_num: instructionNum,

    mango_group: mangoGroup,
    block_datetime: blockDatetime,
    slot: slot,
    signature: signature,
    blocktime: blockTime,
  }
}

function parseUpdateRootBank(
  instructionNum,
  eventData,
  signature,
  blockTime,
  slot,
  blockDatetime
) {
  
  let mangoGroupPk = eventData.mangoGroup.toString();

  let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
    "tokens"
  ];

  let tokenIndex = eventData.tokenIndex.toNumber();
  let depositIndex = new I80F48(eventData.depositIndex).toNumber()
  let borrowIndex = new I80F48(eventData.borrowIndex).toNumber()

  let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
  let token = tokens.find((e) => e["mintKey"] === tokenPk);
  let symbol = token.symbol;

  return {
    symbol: symbol,
    deposit_index: depositIndex,
    borrow_index: borrowIndex,
    instruction_num: instructionNum,
    mango_group: mangoGroupPk,
    block_datetime: blockDatetime,
    slot: slot,
    signature: signature,
    blocktime: blockTime,
    }
}

function parseCachePerpMarkets(
  instructionNum,
  eventData,
  signature,
  blockTime,
  slot,
  blockDatetime
) {

  const config = new Config(IDS);
  
  const groupConfig = config.groups.find((g) =>
    g.publicKey.equals(eventData.mangoGroup)
  ) as GroupConfig;

  let out: any = []
  for (let i=0; i<eventData.marketIndexes.length; i++) {
    let marketIndex = eventData.marketIndexes[i].toNumber()
    let perpMarketConfig = groupConfig.perpMarkets.find(
      (p) => p.marketIndex === marketIndex
    ) as PerpMarketConfig;
    
    out.push(
      {
        symbol: perpMarketConfig.baseSymbol,
        long_funding: new I80F48(eventData.longFundings[i]).toNumber(),
        short_funding: new I80F48(eventData.shortFundings[i]).toNumber(),
        instruction_num: instructionNum,
        mango_group: eventData.mangoGroup.toString(),
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      }
    )
  }

  return out
}

function parseFillLog(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    // instructionNum is used here to form a primary key on the db table (with signature)
    let mangoGroupPk = eventData.mangoGroup.toString();
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
    let marketIndex = eventData.marketIndex.toNumber();
    let perpMarket = perpMarkets.find((e) => e["marketIndex"] === marketIndex);

    let lotSizes = perpLotSizes[mangoGroupPk][perpMarket.name]

    const nativeToUi = Math.pow(10, perpMarket.baseDecimals - perpMarket.quoteDecimals);
    const lotsToNative = lotSizes.quoteLotSize / lotSizes.baseLotSize
    
    const fill = {
      event_num: instructionNum,
      maker: eventData.maker.toString(),
      maker_fee: new I80F48(eventData.makerFee).toNumber(),
      maker_order_id: eventData.makerOrderId.toString(),
      maker_client_order_id: eventData.makerClientOrderId.toString(),
      price: eventData.price.toNumber() * lotsToNative * nativeToUi,
  
      // Storing both price and quantity in UI terms to be consistent with db
      quantity: eventData.quantity.toNumber() * lotSizes.baseLotSize / Math.pow(10, perpMarket.baseDecimals),
  
      seq_num: eventData.seqNum.toNumber(),
      taker: eventData.taker.toString(),
      taker_fee: new I80F48(eventData.takerFee).toNumber(),
      taker_order_id: eventData.takerOrderId.toString(),
      taker_client_order_id: eventData.takerClientOrderId.toString(),
      taker_side: eventData.takerSide === 0 ? 'bid' : 'ask',

      perp_market: perpMarket.name,
      base_symbol: perpMarket.baseSymbol,
      
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };

    return fill;
  }
  
  function parseSettleFees(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
    let mangoAccount = eventData.mangoAccount.toString();
  
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
  
    let marketIndex = eventData.marketIndex.toNumber();
    let perpMarket = perpMarkets.find((e) => e["marketIndex"] === marketIndex);
    let perpMarketName = perpMarket.name;
  
    // TODO: confirm correct conversion from i80f48
    let settlement =
      new I80F48(eventData.settlement).toNumber() /
      Math.pow(10, perpMarket.quoteDecimals);
  
    return {
      margin_account: mangoAccount,
      settlement: settlement,
      perp_market_name: perpMarketName,
      base_symbol: perpMarket.baseSymbol,
      instruction_num: instructionNum,
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseSettlePnl(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
  
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
  
    let mangoAccountA = eventData.mangoAccountA.toString();
    let mangoAccountB = eventData.mangoAccountB.toString();
    let marketIndex = eventData.marketIndex.toNumber();
    let perpMarket = perpMarkets.find((e) => e["marketIndex"] === marketIndex);
    let perpMarketName = perpMarket.name;
    let settlement = new I80F48(eventData.settlement).toNumber();
  
    // A's quote position is reduced by settlement and B's quote position is increased by settlement
    let settlementA = (-1 * settlement) / Math.pow(10, perpMarket.quoteDecimals);
    let settlementB = settlement / Math.pow(10, perpMarket.quoteDecimals);
  
    return [
      {
        margin_account: mangoAccountA,
        settlement: settlementA,
        perp_market_name: perpMarketName,
        base_symbol: perpMarket.baseSymbol,
        counterparty: mangoAccountB,
        instruction_num: instructionNum,
  
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      },
      {
        margin_account: mangoAccountB,
        settlement: settlementB,
        perp_market_name: perpMarketName,
        base_symbol: perpMarket.baseSymbol,
        counterparty: mangoAccountA,
        instruction_num: instructionNum,
  
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      },
    ];
  }
  
  function parsePerpBankruptcy(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    const config = new Config(IDS);
  
    const groupConfig = config.groups.find((g) =>
      g.publicKey.equals(eventData.mangoGroup)
    ) as GroupConfig;
    const perpMarketConfig = groupConfig.perpMarkets.find(
      (p) => p.marketIndex === eventData.liabIndex.toNumber()
    ) as PerpMarketConfig;
  
    let mangoGroupPk = eventData.mangoGroup.toString();
    let liqee = eventData.liqee.toString();
    let liqor = eventData.liqor.toString();
  
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "quoteSymbol"
    ];
    let quoteDecimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroupPk)
      ["tokens"].find((e) => e.symbol === quoteSymbol).decimals;
  
    let liabIndex = eventData.liabIndex.toNumber();
    let perpMarket = perpMarkets.find((e) => e["marketIndex"] === liabIndex);
    let perpMarketName = perpMarket.name;
    let perpBaseSymbol = perpMarket.baseSymbol;
  
    let insuranceFundTransfer =
      eventData.insuranceTransfer.toNumber() / Math.pow(10, quoteDecimals);
  
    // loss is on quote position
    let loss =
      new I80F48(eventData.socializedLoss).toNumber() /
      Math.pow(10, quoteDecimals);
  
    // TODO: are these needed? db columns don't exist
    const cacheLongFunding = new I80F48(eventData.cacheLongFunding).toNumber();
    const cacheShortFunding = new I80F48(eventData.cacheShortFunding).toNumber();
    return [
      {
        liqor: liqor,
        liqee: liqee,
        perp_market_name: perpMarketName,
        perp_base_symbol: perpBaseSymbol,
        insurance_fund_transfer: insuranceFundTransfer,
        loss: loss,
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      },
      {
        symbol: perpMarketConfig.baseSymbol,
        long_funding: cacheLongFunding,
        short_funding: cacheShortFunding,
        instruction_num: instructionNum,
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      },
    ];
  }
  
  function parseTokenBankruptcy(
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
    let liqee = eventData.liqee.toString();
    let liqor = eventData.liqor.toString();
  
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "tokens"
    ];
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "quoteSymbol"
    ];
    let quoteDecimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroupPk)
      ["tokens"].find((e) => e.symbol === quoteSymbol).decimals;
  
    // Either bankruptcy or socialized loss (or both) will be logged
    // So initialize variables as null - nulls can be outputted to json if variables are not set
    let symbol;
    let insuranceFundTransfer: number | null = null;
    let loss: number | null = null;
    let percentageLoss: number | null = null;
    let depositIndex: number | null = null;
  
    // TODO: validate this when an example comes along
  
    let tokenIndex = eventData.liabIndex.toNumber();
    let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
    let token = tokens.find((e) => e["mintKey"] === tokenPk);
    symbol = token.symbol;
  
    insuranceFundTransfer =
      eventData.insuranceTransfer.toNumber() / Math.pow(10, quoteDecimals);
    loss = eventData.socializedLoss.toNumber() / Math.pow(10, token.decimals);
    percentageLoss = eventData.percentageLoss.toNumber();
    symbol = token.symbol;
  
    // TODO: is this needed? didn't see it in the logs
    // depositIndex = socializedLossDetails["deposit_index"]
  
    return {
      liqor: liqor,
      liqee: liqee,
      symbol: symbol,
      insurance_fund_transfer: insuranceFundTransfer,
      loss: loss,
      percentage_loss: percentageLoss,
      deposit_index: depositIndex,
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseLiquidatePerpMarket(
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
    let liqee = eventData.liqee.toString();
    let liqor = eventData.liqor.toString();
    let marketIndex = eventData.marketIndex.toNumber();
  
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "quoteSymbol"
    ];
  
    let perpMarket = perpMarkets.find((e) => e["marketIndex"] === marketIndex);
    let perpMarketName = perpMarket.name;
    let liabDecimals = perpMarket.baseDecimals;
    let assetDecimals = perpMarket.quoteDecimals;
  
    let liabSymbol = perpMarket.baseSymbol;
    let assetSymbol = quoteSymbol;
    let baseTransfer =
      eventData.baseTransfer.toNumber() / Math.pow(10, liabDecimals);
    // TODO: quoteTransfer is -base_transfer * pmi.base_lot_size - but I don't really know what this means
    let quoteTransfer =
      new I80F48(eventData.quoteTransfer).toNumber() /
      Math.pow(10, assetDecimals);
    let bankruptcy = eventData.bankruptcy;
  
    return {
      liqor: liqor,
      liqee: liqee,
      perp_market: perpMarketName,
      liab_symbol: liabSymbol,
      liab_amount: baseTransfer,
      asset_symbol: assetSymbol,
      asset_amount: quoteTransfer,
      bankruptcy: bankruptcy,
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseLiquidateTokenAndPerp(
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
    let liqee = eventData.liqee.toString();
    let liqor = eventData.liqor.toString();
    let assetIndex = eventData.assetIndex.toNumber();
    let liabIndex = eventData.liabIndex.toNumber();
  
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "tokens"
    ];
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ];
  
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "quoteSymbol"
    ];
    let quoteDecimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroupPk)
      ["tokens"].find((e) => e.symbol === quoteSymbol).decimals;
  
    let perpMarket;
    let perpBaseSymbol;
    let assetSymbol;
    let liabSymbol;
  
    let assetType = eventData.assetType === 0 ? 'Token': 'Perp';
    let liabType = eventData.liabType === 0 ? 'Token': 'Perp';
  
    let assetDecimals;
    let liabDecimals;
    let assetTokenPk = tokenIndexesMap[mangoGroupPk][assetIndex];
    let assetToken = tokens.find((e) => e["mintKey"] === assetTokenPk);
    let liabTokenPk = tokenIndexesMap[mangoGroupPk][liabIndex];
    let liabToken = tokens.find((e) => e["mintKey"] === liabTokenPk);
  
    if (assetType === "Token") {
      // asset is token and liab is perp
      assetSymbol = assetToken.symbol;
      assetDecimals = assetToken.decimals;
  
      let liabPerpMarket = perpMarkets.find(
        (e) => e["marketIndex"] === liabIndex
      );
      // Liquidation can only occur on quote position on perp side
      // So I'll set the asset symbol to the quote symbol (as that is what is transferred)
      liabSymbol = quoteSymbol;
      liabDecimals = liabPerpMarket.quoteDecimals;
      perpMarket = liabPerpMarket.name;
      perpBaseSymbol = liabPerpMarket.baseSymbol;
    } else {
      // asset is perp and liab is token
      let assetPerpMarket = perpMarkets.find(
        (e) => e["marketIndex"] === assetIndex
      );
      // Liquidation can only occur on quote position on perp side
      // So I'll set the asset symbol to the quote symbol (as that is what is transferred)
      assetSymbol = quoteSymbol;
      assetDecimals = assetPerpMarket.quoteDecimals;
      perpMarket = assetPerpMarket.name;
      perpBaseSymbol = assetPerpMarket.baseSymbol;
  
      liabSymbol = liabToken.symbol;
      liabDecimals = liabToken.decimals;
    }
  
    let assetPrice =
      new I80F48(eventData.assetPrice).toNumber() *
      Math.pow(10, assetDecimals - quoteDecimals);
    let liabPrice =
      new I80F48(eventData.liabPrice).toNumber() *
      Math.pow(10, liabDecimals - quoteDecimals);
  
    let assetTransfer =
      new I80F48(eventData.assetTransfer).toNumber() /
      Math.pow(10, assetDecimals);
    let liabTransfer =
      new I80F48(eventData.liabTransfer).toNumber() /
      Math.pow(10, liabDecimals);
  
    return {
      liqor: liqor,
      liqee: liqee,
      perp_market: perpMarket,
      liab_symbol: liabSymbol,
      liab_amount: liabTransfer,
      liab_price: liabPrice,
      liab_type: liabType,
      asset_symbol: assetSymbol,
      asset_amount: assetTransfer,
      asset_price: assetPrice,
      asset_type: assetType,
      perp_base_symbol: perpBaseSymbol,
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseLiquidateTokenAndToken(
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroup = eventData.mangoGroup.toString();
    let liqee = eventData.liqee.toString();
    let liqor = eventData.liqor.toString();
    let assetIndex = eventData.assetIndex.toNumber();
    let liabIndex = eventData.liabIndex.toNumber();
  
    let assetToken = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroup)
      ["tokens"].find(
        (e) => e.mintKey === tokenIndexesMap[mangoGroup][assetIndex]
      );
    let liabToken = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroup)
      ["tokens"].find(
        (e) => e.mintKey === tokenIndexesMap[mangoGroup][liabIndex]
      );
  
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroup)[
      "quoteSymbol"
    ];
    let quoteDecimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroup)
      ["tokens"].find((e) => e.symbol === quoteSymbol).decimals;
  
    let assetPrice =
      new I80F48(eventData.assetPrice).toNumber() *
      Math.pow(10, assetToken.decimals - quoteDecimals);
    let liabPrice =
      new I80F48(eventData.liabPrice).toNumber() *
      Math.pow(10, liabToken.decimals - quoteDecimals);
  
    // TODO: confirm that this is correct
    let assetTransfer =
      new I80F48(eventData.assetTransfer).toNumber() /
      Math.pow(10, assetToken.decimals);
    let liabTransfer =
      new I80F48(eventData.liabTransfer).toNumber() /
      Math.pow(10, liabToken.decimals);
  
    let bankruptcy = eventData.bankruptcy;
  
    return {
      liqor: liqor,
      liqee: liqee,
      liab_symbol: liabToken.symbol,
      liab_amount: liabTransfer,
      liab_price: liabPrice,
      asset_symbol: assetToken.symbol,
      asset_amount: assetTransfer,
      asset_price: assetPrice,
      bankruptcy: bankruptcy,
      mango_group: mangoGroup,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseRedeemMngo(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroup = eventData.mangoGroup.toString();
    let marginAccount = eventData.mangoAccount.toString();

    const config = new Config(IDS);
    const groupConfig = config.groups.find((g) =>
      g.publicKey.equals(eventData.mangoGroup)
    ) as GroupConfig;
    
    let perpMarketConfig = groupConfig.perpMarkets.find(
      (p) => p.marketIndex === eventData.marketIndex.toNumber()
    ) as PerpMarketConfig;

    let decimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroup)
      ["tokens"].find((e) => e.symbol === "MNGO").decimals;

    let perpMarketName = perpMarketConfig.name
    let baseSymbol = perpMarketConfig.baseSymbol

    let quantity = eventData.redeemedMngo.toNumber() / Math.pow(10, decimals);
  
    return {
      margin_account: marginAccount,
      quantity: quantity,
      instruction_num: instructionNum,
      mango_group: mangoGroup,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
      perp_market: perpMarketName,
      base_symbol: baseSymbol
    };
  }
  
  function parseDepositWithDraw(
    instructionNum,
    eventData,
    eventName,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroup = eventData.mangoGroup.toString();
    let marginAccount = eventData.mangoAccount.toString();
    let owner = eventData.owner.toString();
    let tokenIndex = eventData.tokenIndex.toNumber();
    let nativeQuantity = eventData.quantity.toNumber();
  
    let side;
    if (eventName === "DepositLog") {
      side = "Deposit";
    } else if (eventName === "WithdrawLog") {
      side = "Withdraw";
    }
  
    let tokenPk = tokenIndexesMap[mangoGroup][tokenIndex];
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroup)[
      "tokens"
    ];
    let token = tokens.find((e) => e["mintKey"] === tokenPk);
    let mintDecimals = token.decimals;
    let symbol = token.symbol;
  
    let quantity = nativeQuantity / Math.pow(10, mintDecimals);
  
    return {
      margin_account: marginAccount,
      owner: owner,
      symbol: symbol,
      side: side,
      quantity: quantity,
      instruction_num: instructionNum,
      mango_group: mangoGroup,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseTokenBalance(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    const mangoGroupPk = eventData.mangoGroup.toString();
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "tokens"
    ];
    let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
      'quoteSymbol'
    ];
    let quoteDecimals = ids['groups']
      .find((e) => e['publicKey'] === mangoGroupPk)
      ['tokens'].find((e) => e.symbol === quoteSymbol).decimals;

    let mangoAccountPk = eventData.mangoAccount.toString();
    let tokenIndex = eventData.tokenIndex.toNumber();
  
    let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
    let token = tokens.find((e) => e["mintKey"] === tokenPk);
    let symbol = token.symbol;

    let deposit = new I80F48(eventData.deposit)
      .div(I80F48.fromNumber(Math.pow(10, token.decimals - quoteDecimals)))
      .toNumber();
    let borrow = new I80F48(eventData.borrow)
      .div(I80F48.fromNumber(Math.pow(10, token.decimals - quoteDecimals)))
      .toNumber();
  
    return {
      mango_account: mangoAccountPk,
      symbol: symbol,
      deposit: deposit,
      borrow: borrow,
      mango_group: mangoGroupPk,
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseCacheRootBanks(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
  
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "tokens"
    ];
  
    let cacheIndexes: any = [];
  
    let tokenIndexes = eventData.tokenIndexes.map((i) => i.toNumber());
    let depositIndexes = eventData.depositIndexes.map((i) =>
      new I80F48(i).toNumber()
    );
    let borrowIndexes = eventData.borrowIndexes.map((i) =>
      new I80F48(i).toNumber()
    );
  
    for (let i = 0; i < tokenIndexes.length; i++) {
      let tokenIndex = tokenIndexes[i];
  
      let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
      let token = tokens.find((e) => e["mintKey"] === tokenPk);
      let symbol = token.symbol;
  
      let depositIndex = depositIndexes[i];
      let borrowIndex = borrowIndexes[i];
  
      cacheIndexes.push({
        symbol: symbol,
        deposit_index: depositIndex,
        borrow_index: borrowIndex,
        instruction_num: instructionNum,
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      });
    }
  
    return cacheIndexes;
  }
  
  function parseCachePrices(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    let mangoGroupPk = eventData.mangoGroup.toString();
  
    // Some symbols may only exist in tokens or perpMarkets but not both (such as ADA)
    let tokens = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "tokens"
    ];
    let perpMarkets = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "perpMarkets"
    ]
    let symbolDecimalsMap = Object.fromEntries(tokens.map(e => [e.symbol, e.decimals]).concat(perpMarkets.map(e => [e.baseSymbol, e.baseDecimals])))


    let oracles = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "oracles"
    ];
    let quoteSymbol = ids["groups"].find((e) => e["publicKey"] === mangoGroupPk)[
      "quoteSymbol"
    ];
    let quoteDecimals = ids["groups"]
      .find((e) => e["publicKey"] === mangoGroupPk)
      ["tokens"].find((e) => e.symbol === quoteSymbol).decimals;
  
    let cachePrices: any = [];
    let oracleIndexes = eventData.oracleIndexes.map((i) => i.toNumber());
    let oraclePrices = eventData.oraclePrices.map((p) => new I80F48(p));
  
    for (let [i, oracleIndex] of oracleIndexes.entries()) {
      let oraclePk = oracleIndexesMap[mangoGroupPk][oracleIndex];
      let oracle = oracles.find((e) => e["publicKey"] === oraclePk);
      let symbol = oracle.symbol;
  
      let baseDecimals = symbolDecimalsMap[symbol]
  
      let rawPrice = oraclePrices[i];
      let price = rawPrice
        .mul(I80F48.fromNumber(Math.pow(10, baseDecimals - quoteDecimals)))
        .toNumber();
  
      cachePrices.push({
        symbol: symbol,
        price: price,
        oracle_pk: oraclePk,
        instruction_num: instructionNum,
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      });
    }
  
    return cachePrices;
  }
  
  function parseUpdateFunding(
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    const config = new Config(IDS);
  
    const groupConfig = config.groups.find((g) =>
      g.publicKey.equals(eventData.mangoGroup)
    ) as GroupConfig;
    const perpMarketConfig = groupConfig.perpMarkets.find(
      (p) => p.marketIndex === eventData.marketIndex.toNumber()
    ) as PerpMarketConfig;

    return {
      symbol: perpMarketConfig.baseSymbol,
      long_funding: new I80F48(eventData.longFunding).toNumber(),
      short_funding: new I80F48(eventData.shortFunding).toNumber(),
      instruction_num: instructionNum,
      mango_group: eventData.mangoGroup.toString(),
      block_datetime: blockDatetime,
      slot: slot,
      signature: signature,
      blocktime: blockTime,
    };
  }
  
  function parseCancelAllPerpOrders (
    instructionNum,
    eventData,
    signature,
    blockTime,
    slot,
    blockDatetime
  ) {
    const config = new Config(IDS);

    const groupConfig = config.groups.find((g) =>
      g.publicKey.equals(eventData.mangoGroup)
    ) as GroupConfig;
  
    let perpMarketConfig = groupConfig.perpMarkets.find(
      (p) => p.marketIndex === eventData.marketIndex.toNumber()
    ) as PerpMarketConfig;

    let mangoGroupPk = eventData.mangoGroup.toString();
    let mangoAccount = eventData.mangoAccount.toString();

    let allOrderIds = eventData.allOrderIds.map(e => e.toString())
    let cancelledOrderIds = eventData.canceledOrderIds.map(e => e.toString())

    let cancelled;
    let result: any = [];
    for (let orderId of allOrderIds) {
      
      if (cancelledOrderIds.includes(orderId)) {
        cancelled = true
      } else {
        cancelled = false
      }

      result.push({
        order_id: orderId,
        cancelled: cancelled,
        perp_market: perpMarketConfig.name,
        base_symbol: perpMarketConfig.baseSymbol,
        
        mango_account: mangoAccount,
        instruction_num: instructionNum,
        mango_group: mangoGroupPk,
        block_datetime: blockDatetime,
        slot: slot,
        signature: signature,
        blocktime: blockTime,
      });
      
    }

    return result;
  }