import Decimal from 'decimal.js';

import BN from 'bn.js';
import { HermesClient } from '@pythnetwork/hermes-client';
import {
    AccountInfo, ComputeBudgetProgram, Connection, Keypair, PACKET_DATA_SIZE, PublicKey, Signer,
    SystemProgram, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction
} from '@solana/web3.js';

import { HUNDRED_PERCENT_BPS } from '../../constants';
import { OracleSettings } from '../../layouts/oracle';
import { TxBatchData, TxData } from '../../txUtils';
import { HERMES_PUBLIC_ENDPOINT, SOLANA_DEVNET_ENDPOINT } from './constants';
import { OraclePrice } from './oracle';

export type VerificationLevel =
  | { kind: 'Partial'; numSignatures: number }
  | { kind: 'Full' };

export function parseVerificationLevel(buf: Buffer, offset: number): { level: VerificationLevel, size: number } {
    const discr = buf.readUInt8(offset);
    if (discr === 0) { // Partial
        const numSignatures = buf.readUInt8(offset + 1);
        return { level: { kind: 'Partial', numSignatures }, size: 2 };
    } else if (discr === 1) { // Full
        return { level: { kind: 'Full' }, size: 1 };
    } else {
        throw new Error(`Unknown verification level: ${discr}`);
    }
}

// Pyth program IDs (mainnet)
const DEFAULT_RECEIVER_PROGRAM_ID = new PublicKey("rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ");
const DEFAULT_PUSH_ORACLE_PROGRAM_ID = new PublicKey("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
const DEFAULT_WORMHOLE_PROGRAM_ID = new PublicKey("HDwcJBJXjL9FpJ7UBsYBtaDjsBUhuLCUYoz3zr8SWWaQ");

// Constants from Pyth SDK vaa.js
const VAA_START = 46;
const VAA_SPLIT_INDEX = 721;
const VAA_SIGNATURE_SIZE = 66;
const DEFAULT_REDUCED_GUARDIAN_SET_SIZE = 5;


// Compute budget constants
const VERIFY_ENCODED_VAA_COMPUTE_BUDGET = 350_000;
const UPDATE_PRICE_FEED_COMPUTE_BUDGET = 55_000;
const INIT_ENCODED_VAA_COMPUTE_BUDGET = 3000;
const WRITE_ENCODED_VAA_COMPUTE_BUDGET = 3000;
const CLOSE_ENCODED_VAA_COMPUTE_BUDGET = 30_000;


// Pre-computed discriminators
const DISCRIMINATORS = {
    // Wormhole instructions
    initEncodedVaa: Buffer.from([209, 193, 173, 25, 91, 202, 181, 218]),
    writeEncodedVaa: Buffer.from([199, 208, 110, 177, 150, 76, 118, 42]),
    verifyEncodedVaaV1: Buffer.from([103, 56, 177, 229, 240, 103, 68, 73]),
    closeEncodedVaa: Buffer.from([48, 221, 174, 198,231, 7, 152, 38]),
    // Pyth Push Oracle instructions  
    updatePriceFeed: Buffer.from([28, 9, 93, 150, 86, 153, 188, 115]),
};

// Jito tip accounts (copied from pyth solana-utils)
export const TIP_ACCOUNTS = [
  "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe",
  "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
  "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
  "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
  "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
  "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
  "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
  "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
];

export function getRandomTipAccount(): PublicKey {
  const idx = Math.floor(Math.random() * TIP_ACCOUNTS.length);
  return new PublicKey(TIP_ACCOUNTS[idx]);
}

export function buildJitoTipInstruction(payer: PublicKey, lamports: number): TransactionInstruction {
  return SystemProgram.transfer({
    fromPubkey: payer,
    toPubkey: getRandomTipAccount(),
    lamports,
  });
}

/**
 * Get a random treasury ID (0-255) - same as Pyth SDK's getRandomTreasuryId()
 */
function getRandomTreasuryId(): number {
    return Math.floor(Math.random() * 256);
}

/**
 * Derives the Pyth price feed account address
 */
export function getPythPriceFeedAccountAddress(
    shardId: number,
    priceFeedId: string | Buffer,
    pushOracleProgramId: PublicKey = DEFAULT_PUSH_ORACLE_PROGRAM_ID
): PublicKey {
    let feedIdBuffer: Buffer;
    if (typeof priceFeedId === "string") {
        const hexString = priceFeedId.startsWith("0x") 
            ? priceFeedId.slice(2) 
            : priceFeedId;
        feedIdBuffer = Buffer.from(hexString, "hex");
    } else {
        feedIdBuffer = priceFeedId;
    }
    
    if (feedIdBuffer.length !== 32) {
        throw new Error("Feed ID should be 32 bytes long");
    }
    
    const shardBuffer = Buffer.alloc(2);
    shardBuffer.writeUint16LE(shardId, 0);
    
    return PublicKey.findProgramAddressSync(
        [shardBuffer, feedIdBuffer],
        pushOracleProgramId
    )[0];
}

/**
 * Get Treasury PDA for Pyth Receiver
 */
function getTreasuryPda(treasuryId: number, programId: PublicKey = DEFAULT_RECEIVER_PROGRAM_ID): PublicKey {
    return PublicKey.findProgramAddressSync(
        [Buffer.from("treasury"), Buffer.from([treasuryId])],
        programId
    )[0];
}

/**
 * Get Config PDA for Pyth Receiver
 */
function getConfigPda(programId: PublicKey = DEFAULT_RECEIVER_PROGRAM_ID): PublicKey {
    return PublicKey.findProgramAddressSync(
        [Buffer.from("config")],
        programId
    )[0];
}

/**
 * Get Guardian Set PDA for Wormhole
 */
function getGuardianSetPda(guardianSetIndex: number, programId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID): PublicKey {
    const indexBuffer = Buffer.alloc(4);
    indexBuffer.writeUInt32BE(guardianSetIndex, 0);
    return PublicKey.findProgramAddressSync(
        [Buffer.from("GuardianSet"), indexBuffer],
        programId
    )[0];
}

/**
 * Get guardian set index from VAA (offset 1, big-endian u32)
 */
function getGuardianSetIndex(vaa: Buffer): number {
    return vaa.readUInt32BE(1);
}


/**
 * Serialize Borsh Vec<u8> (4-byte LE length prefix + data)
 */
function serializeBorshBytes(data: Buffer): Buffer {
    const lenBuffer = Buffer.alloc(4);
    lenBuffer.writeUInt32LE(data.length, 0);
    return Buffer.concat([lenBuffer, data]);
}

/**
 * Serialize Borsh Vec<[u8; 20]> for merkle proof
 */
function serializeBorshProof(proof: Buffer[]): Buffer {
    const lenBuffer = Buffer.alloc(4);
    lenBuffer.writeUInt32LE(proof.length, 0);
    return Buffer.concat([lenBuffer, ...proof]);
}

export interface InstructionWithSigners {
    instruction: TransactionInstruction;
    signers: Keypair[];
    computeUnits?: number;
}

/**
 * Build initEncodedVaa instruction
 */
function buildInitEncodedVaaInstruction(
    writeAuthority: PublicKey,
    encodedVaa: PublicKey,
    wormholeProgramId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID
): TransactionInstruction {
    return new TransactionInstruction({
        keys: [
            { pubkey: writeAuthority, isSigner: true, isWritable: false },
            { pubkey: encodedVaa, isSigner: false, isWritable: true },
        ],
        programId: wormholeProgramId,
        data: DISCRIMINATORS.initEncodedVaa,
    });
}



/**
 * Build writeEncodedVaa instruction
 */
function buildWriteEncodedVaaInstruction(
    writeAuthority: PublicKey,
    draftVaa: PublicKey,
    index: number,
    data: Buffer,
    wormholeProgramId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID
): TransactionInstruction {
    // Serialize args: index (u32 LE) + data (Borsh Vec<u8>)
    const indexBuffer = Buffer.alloc(4);
    indexBuffer.writeUInt32LE(index, 0);
    
    const instructionData = Buffer.concat([
        DISCRIMINATORS.writeEncodedVaa,
        indexBuffer,
        serializeBorshBytes(data),
    ]);
    
    return new TransactionInstruction({
        keys: [
            { pubkey: writeAuthority, isSigner: true, isWritable: false },
            { pubkey: draftVaa, isSigner: false, isWritable: true },
        ],
        programId: wormholeProgramId,
        data: instructionData,
    });
}

/**
 * Build verifyEncodedVaaV1 instruction
 */
function buildVerifyEncodedVaaV1Instruction(
    writeAuthority: PublicKey,
    draftVaa: PublicKey,
    guardianSetIndex: number,
    wormholeProgramId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID
): TransactionInstruction {
    return new TransactionInstruction({
        keys: [
            { pubkey: writeAuthority, isSigner: true, isWritable: false },
            { pubkey: draftVaa, isSigner: false, isWritable: true },
            { pubkey: getGuardianSetPda(guardianSetIndex, wormholeProgramId), isSigner: false, isWritable: false },
        ],
        programId: wormholeProgramId,
        data: DISCRIMINATORS.verifyEncodedVaaV1,
    });
}

/**
 * Build closeEncodedVaa instruction
 */
function buildCloseEncodedVaaInstruction(
    writeAuthority: PublicKey,
    encodedVaa: PublicKey,
    wormholeProgramId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID
): TransactionInstruction {
    return new TransactionInstruction({
        keys: [
            { pubkey: writeAuthority, isSigner: true, isWritable: true },
            { pubkey: encodedVaa, isSigner: false, isWritable: true },
        ],
        programId: wormholeProgramId,
        data: DISCRIMINATORS.closeEncodedVaa,
    });
}

/**
 * Build updatePriceFeed instruction for Pyth Push Oracle
 */
function buildUpdatePriceFeedInstruction(params: {
    payer: PublicKey;
    encodedVaa: PublicKey;
    priceFeedAccount: PublicKey;
    treasuryId: number;
    shardId: number;
    feedId: Buffer;
    merklePriceUpdate: { message: Buffer; proof: Buffer[] };
    receiverProgramId?: PublicKey;
    pushOracleProgramId?: PublicKey;
}): TransactionInstruction {
    const {
        payer,
        encodedVaa,
        priceFeedAccount,
        treasuryId,
        shardId,
        feedId,
        merklePriceUpdate,
        receiverProgramId = DEFAULT_RECEIVER_PROGRAM_ID,
        pushOracleProgramId = DEFAULT_PUSH_ORACLE_PROGRAM_ID,
    } = params;
    
    
    const shardBuffer = Buffer.alloc(2);
    shardBuffer.writeUint16LE(shardId, 0);
    
    const data = Buffer.concat([
        DISCRIMINATORS.updatePriceFeed,
        // MerklePriceUpdate
        serializeBorshBytes(merklePriceUpdate.message),
        serializeBorshProof(merklePriceUpdate.proof),
        // treasuryId (u8)
        Buffer.from([treasuryId]),
        // shardId (u16 LE)
        shardBuffer,
        // feedId ([u8; 32])
        feedId,
    ]);

    const keys = [
        { pubkey: payer, isSigner: true, isWritable: true },
        { pubkey: receiverProgramId, isSigner: false, isWritable: false },
        { pubkey: encodedVaa, isSigner: false, isWritable: false },
        { pubkey: getConfigPda(receiverProgramId), isSigner: false, isWritable: false },
        { pubkey: getTreasuryPda(treasuryId, receiverProgramId), isSigner: false, isWritable: true },
        { pubkey: priceFeedAccount, isSigner: false, isWritable: true },
        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
    ];
    
    return new TransactionInstruction({
        keys,
        programId: pushOracleProgramId,
        data,
    });
}


export interface PythUpdateResult {
    postInstructions: InstructionWithSigners[];
    closeInstructions: InstructionWithSigners[];
    signers: Keypair[];
    priceFeedAccounts: Map<string, PublicKey>;
}


/**
 * Convert proof from number[][] to Buffer[]
 */
function convertProof(proof: number[][]): Buffer[] {
    return proof.map(p => Buffer.from(p));
}

export function parsePriceFeedMessage(message: Buffer) {
  let cursor = 0;
  const variant = message.readUInt8(cursor); cursor += 1;
  if (variant !== 0) throw new Error('Not a price feed message');
  const feedId = message.subarray(cursor, cursor + 32); cursor += 32;
  const price = message.subarray(cursor, cursor + 8); cursor += 8;
  const confidence = message.subarray(cursor, cursor + 8); cursor += 8;
  const exponent = message.readInt32BE(cursor); cursor += 4;
  const publishTime = message.subarray(cursor, cursor + 8); cursor += 8;
  const prevPublishTime = message.subarray(cursor, cursor + 8); cursor += 8;
  const emaPrice = message.subarray(cursor, cursor + 8); cursor += 8;
  const emaConf = message.subarray(cursor, cursor + 8);
  return { feedId, price, confidence, exponent, publishTime, prevPublishTime, emaPrice, emaConf };
}

/** parsing of accumulator update data (VAA + updates) */
export function parseAccumulatorUpdateData(data: Buffer): { vaa: Buffer; updates: { message: Buffer; proof: number[][] }[] } {
  const ACC_MAGIC = '504e4155';
  if (data.toString('hex').slice(0, 8) !== ACC_MAGIC || data[4] !== 1 || data[5] !== 0) {
    throw new Error('Invalid accumulator message');
  }
  let cursor = 6;
  const trailingPayloadSize = data.readUInt8(cursor); cursor += 1 + trailingPayloadSize;
  cursor += 1;
  const vaaSize = data.readUInt16BE(cursor); cursor += 2;
  const vaa = data.subarray(cursor, cursor + vaaSize); cursor += vaaSize;
  const numUpdates = data.readUInt8(cursor); cursor += 1;
  const updates: { message: Buffer; proof: number[][] }[] = [];
  const HASH_SIZE = 20;
  for (let i = 0; i < numUpdates; i++) {
    const messageSize = data.readUInt16BE(cursor); cursor += 2;
    const message = data.subarray(cursor, cursor + messageSize); cursor += messageSize;
    const numProofs = data.readUInt8(cursor); cursor += 1;
    const proof: number[][] = [];
    for (let j = 0; j < numProofs; j++) {
      proof.push(Array.from(data.subarray(cursor, cursor + HASH_SIZE)));
      cursor += HASH_SIZE;
    }
    updates.push({ message, proof });
  }
  if (cursor !== data.length) throw new Error("Didn't reach end of message");
  return { vaa, updates };
}



/**
 * Get the size of a transaction that would contain the provided array of instructions
 */
export function getSizeOfTransaction(
  instructions: TransactionInstruction[],
  versionedTransaction: boolean = true,
  addressLookupTable?: { state: { addresses: PublicKey[] } }
): number {
  const programs = new Set<string>();
  const signers = new Set<string>();
  let accounts = new Set<string>();
  instructions.map((ix) => {
    programs.add(ix.programId.toBase58());
    accounts.add(ix.programId.toBase58());
    ix.keys.map((key) => {
      if (key.isSigner) {
        signers.add(key.pubkey.toBase58());
      }
      accounts.add(key.pubkey.toBase58());
    });
  });
  const instruction_sizes = instructions
    .map(
      (ix) =>
        1 +
        getSizeOfCompressedU16(ix.keys.length) +
        ix.keys.length +
        getSizeOfCompressedU16(ix.data.length) +
        ix.data.length
    )
    .reduce((a, b) => a + b, 0);
  let numberOfAddressLookups = 0;
  if (addressLookupTable) {
    const lookupTableAddresses = addressLookupTable.state.addresses.map((address) => address.toBase58());
    const totalNumberOfAccounts = accounts.size;
    accounts = new Set([...accounts].filter((account) => !lookupTableAddresses.includes(account)));
    accounts = new Set([...accounts, ...programs, ...signers]);
    numberOfAddressLookups = totalNumberOfAccounts - accounts.size;
  }
  return (
    getSizeOfCompressedU16(signers.size) +
    signers.size * 64 +
    3 +
    getSizeOfCompressedU16(accounts.size) +
    32 * accounts.size +
    32 +
    getSizeOfCompressedU16(instructions.length) +
    instruction_sizes +
    (versionedTransaction ? 1 + getSizeOfCompressedU16(0) : 0) +
    (versionedTransaction && addressLookupTable ? 32 : 0) +
    (versionedTransaction && addressLookupTable ? 2 : 0) +
    numberOfAddressLookups
  );
}

/** Get the size of n in bytes when serialized as a CompressedU16 */
export function getSizeOfCompressedU16(n: number): number {
  return 1 + Number(n >= 128) + Number(n >= 16384);
}





const ENCODED_VAA_RENT_EXEMPTION = 7_836_960;

export interface InstructionBatch {
    instructions: TransactionInstruction[];
    signers: Keypair[];
    computeUnits: number;
}

/**
 * Fetch Pyth price accounts from RPC and extract feed IDs
 */
export async function fetchFeedIdsFromAccounts(
    connection: Connection,
    priceAccounts: PublicKey[],
): Promise<{ feedIds: string[], feedIdToAccount: Map<string, PublicKey> }> {
    const accountInfos = await connection.getMultipleAccountsInfo(priceAccounts, "confirmed");
    const feedIds: string[] = [];
    const feedIdToAccount = new Map<string, PublicKey>();

    for (let i = 0; i < priceAccounts.length; i++) {
        const ai = accountInfos[i];
        if (!ai) throw new Error(`Account ${priceAccounts[i].toBase58()} not found`);
        const [state, _] = PythState.decode(ai.data, 8);
        const feedIdHex = "0x" + state.priceMessage.feedId.toString("hex");
        feedIds.push(feedIdHex);
        feedIdToAccount.set(feedIdHex, priceAccounts[i]);
    }

    return { feedIds, feedIdToAccount };
}


export interface PythUpdateTxResult {
    txBatchData: TxBatchData;
    /** Keypairs that must sign their respective transactions before sending */
    extraSigners: Map<number, Keypair[]>; // batchIndex -> signers for tx[0] in that batch
}

/**
 * Build Pyth price feed update as TxBatchData compatible with SDK txUtils.
 * 
 * TxBatchData.batches layout:
 *   batch 0 (sequential): [createAccount + initEncodedVaa + writeVaa_part1]
 *   batch 1 (sequential): [writeVaa_part2 + verifyEncodedVaa]
 *   batch 2 (parallel):   [updateFeed_0], [updateFeed_1], ... [updateFeed_N-2]
 *   batch 3 (sequential): [updateFeed_last + closeEncodedVaa]
 * 
 * Transactions within each batch are sent in parallel by sendVersionedTxs.
 * Batches are sent sequentially.
 */
export async function buildPythPriceFeedUpdateIxs(
  payer: PublicKey,
  priceFeedIds: string[],
  defaultShardId?: number,
  hermesClient?: HermesClient,
): Promise<{
  vaaCreateInitEncodeIxs: { ixs: TransactionInstruction[]; signer: Keypair; }[];
  vaaWriteVerifyIxs: TransactionInstruction[][];
  updateFeedIxs: TransactionInstruction[];
  closeVaaIxs: TransactionInstruction[];
}> {
    const client = hermesClient ?? new HermesClient(HERMES_PUBLIC_ENDPOINT, {});
    const shardId = defaultShardId ?? 0;
    const priceUpdates = await client.getLatestPriceUpdates(priceFeedIds, { encoding: "base64" });

    if (!priceUpdates.binary?.data || priceUpdates.binary.data.length === 0) {
        throw new Error("Failed to fetch price updates from Hermes");
    }

    const treasuryId = getRandomTreasuryId();

    let allVaaCreateInitEncodeIxs: { ixs: TransactionInstruction[]; signer: Keypair; }[] = [];
    let allVaaWriteVerifyIxs: TransactionInstruction[][] = [];
    const allUpdateIxs: TransactionInstruction[] = [];
    const allCloseIxs: TransactionInstruction[] = [];

    for (const updateData of priceUpdates.binary.data) {
        const accumulatorData = parseAccumulatorUpdateData(Buffer.from(updateData, "base64"));
        const vaa = accumulatorData.vaa;
        const encodedVaaKeypair = Keypair.generate();
        const encodedVaaSize = vaa.length + VAA_START;
        const guardianSetIndex = getGuardianSetIndex(vaa);

        let vaaCreateInitEncodeIxs: TransactionInstruction[] = [];
        let vaaWriteVerifyIxs: TransactionInstruction[] = [];

        // createAccount
        vaaCreateInitEncodeIxs.push(
          SystemProgram.createAccount({
            fromPubkey: payer,
            newAccountPubkey: encodedVaaKeypair.publicKey,
            lamports: ENCODED_VAA_RENT_EXEMPTION,
            space: encodedVaaSize,
            programId: DEFAULT_WORMHOLE_PROGRAM_ID,
          })
        );

        // initEncodedVaa
        vaaCreateInitEncodeIxs.push(
          buildInitEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey)
        );

        // writeEncodedVaa part 1
        const firstPartEnd = Math.min(VAA_SPLIT_INDEX, vaa.length);
        vaaCreateInitEncodeIxs.push(
          buildWriteEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey, 0, vaa.subarray(0, firstPartEnd))
        );

        // writeEncodedVaa part 2 (if needed)
        if (vaa.length > VAA_SPLIT_INDEX) {
          vaaWriteVerifyIxs.push(
              buildWriteEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey, VAA_SPLIT_INDEX, vaa.subarray(VAA_SPLIT_INDEX))
            );
        }

        // verifyEncodedVaaV1
        vaaWriteVerifyIxs.push(
          buildVerifyEncodedVaaV1Instruction(payer, encodedVaaKeypair.publicKey, guardianSetIndex)
        );

        // updateFeed per price update
        for (const update of accumulatorData.updates) {
            const parsedMessage = parsePriceFeedMessage(update.message);
            const feedId = parsedMessage.feedId;

            allUpdateIxs.push(
                buildUpdatePriceFeedInstruction({
                    payer,
                    encodedVaa: encodedVaaKeypair.publicKey,
                    priceFeedAccount: getPythPriceFeedAccountAddress(shardId, feedId),
                    treasuryId,
                    shardId,
                    feedId,
                    merklePriceUpdate: {
                        message: update.message,
                        proof: convertProof(update.proof),
                    },
                }),
            );
        }

        allVaaCreateInitEncodeIxs.push({
          ixs: vaaCreateInitEncodeIxs,
          signer: encodedVaaKeypair,
        });
        allVaaWriteVerifyIxs.push(vaaWriteVerifyIxs);
        // closeEncodedVaa
        allCloseIxs.push(
            buildCloseEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey),
        );
    }

    return {
        vaaCreateInitEncodeIxs: allVaaCreateInitEncodeIxs,
        vaaWriteVerifyIxs: allVaaWriteVerifyIxs,
        updateFeedIxs: allUpdateIxs,
        closeVaaIxs: allCloseIxs,
    };
}


export class PriceFeedMessage {
    feedId: Buffer;
    price: BN; // i64 (signed)
    conf: BN;  // u64
    exponent: number; // i32
    publishTime: BN; // i64
    prevPublishTime: BN; // i64
    emaPrice: BN; // i64
    emaConf: BN; // u64

    constructor(params: {
        feedId: Buffer,
        price: BN,
        conf: BN,
        exponent: number,
        publishTime: BN,
        prevPublishTime: BN,
        emaPrice: BN,
        emaConf: BN
    }) {
        this.feedId = params.feedId;
        this.price = params.price;
        this.conf = params.conf;
        this.exponent = params.exponent;
        this.publishTime = params.publishTime;
        this.prevPublishTime = params.prevPublishTime;
        this.emaPrice = params.emaPrice;
        this.emaConf = params.emaConf;
    }

    static decode(buf: Buffer, offset: number = 0): [PriceFeedMessage, number] {
        let cursor = offset;

        // feed_id: [u8;32]
        const feedId = buf.subarray(cursor, cursor + 32);
        cursor += 32;

        // price: i64 (signed)
        const price = new BN(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
        cursor += 8;

        // conf: u64 (unsigned)
        const conf = new BN(buf.subarray(cursor, cursor + 8), "le");
        cursor += 8;

        // exponent: i32 (signed)
        const exponent = new BN(buf.subarray(cursor, cursor + 4), "le").fromTwos(32).toNumber();
        cursor += 4;

        // publish_time: i64 (signed)
        const publishTime = new BN(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
        cursor += 8;

        // prev_publish_time: i64 (signed)
        const prevPublishTime = new BN(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
        cursor += 8;

        // ema_price: i64 (signed)
        const emaPrice = new BN(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
        cursor += 8;

        // ema_conf: u64 (unsigned)
        const emaConf = new BN(buf.subarray(cursor, cursor + 8), "le");
        cursor += 8;

        return [ new PriceFeedMessage({
            feedId,
            price,
            conf,
            exponent,
            publishTime,
            prevPublishTime,
            emaPrice,
            emaConf
        }), cursor ];
    }
}

export class PythState {
    writeAuthority: PublicKey;
    verificationLevel: VerificationLevel;
    priceMessage: PriceFeedMessage;
    postedSlot: BN;

    constructor(
        writeAuthority: PublicKey,
        verificationLevel: VerificationLevel,
        priceMessage: PriceFeedMessage,
        postedSlot: BN
    ) {
        this.writeAuthority = writeAuthority;
        this.verificationLevel = verificationLevel;
        this.priceMessage = priceMessage;
        this.postedSlot = postedSlot;
    };

    static decode(buf: Buffer, offset: number = 0): [PythState, number] {
        let cursor = offset;
        // write_authority: Pubkey (32)
        const writeAuthority = new PublicKey(buf.subarray(cursor, cursor + 32));
        cursor += 32;

        const { level, size } = parseVerificationLevel(buf, cursor);
        cursor += size;

        // price_message: PriceFeedMessage
        const [priceMessage, next] = PriceFeedMessage.decode(buf, cursor);
        cursor = next;

        // posted_slot: u64
        const postedSlot = new BN(buf.subarray(cursor, cursor + 8), "le");
        cursor += 8;

        return [ new PythState(writeAuthority, level, priceMessage, postedSlot), cursor ];
    }
    
}


export class PythOracle {
    
    static fetch(
        oracleParams: OracleSettings,
        accountInfos: AccountInfo<Buffer>[],
        solPrice?: OraclePrice,
        usdPrice?: OraclePrice,
    ): OraclePrice {
        //@ts-ignore
        let state: PythState = null;
        try {
            const stateAi = accountInfos[0];
            const [parsedState, _] = PythState.decode(stateAi.data, 8);
            state = parsedState;
        } catch (error) {
            return new OraclePrice(new Decimal(0), new Decimal(0), 0);
        }

        let pr = new Decimal(state.priceMessage.price.toString()).mul(Decimal.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
        let ema = new Decimal(state.priceMessage.emaPrice.toString()).mul(Decimal.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
        let cf = new Decimal(state.priceMessage.conf.toString()).mul(Decimal.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
        const lastUpdateTimestamp = state.priceMessage.publishTime;

        // Validate primary price is not zero
        if (pr.lte(0)) {
            return new OraclePrice(new Decimal(0), new Decimal(0), 0);
        }

        // === 1. Inflate confidence by staleness ===
        // confidence = confidence * (1 + delta_t * stalenessConfRateBps / 10_000)
        const now: BN = new BN(Math.floor(Date.now() / 1000));
        const deltaSeconds = Math.max(now.toNumber() - lastUpdateTimestamp.toNumber(), 0);
        const deltaT = new Decimal(deltaSeconds);
        const deltaTBN = new BN(deltaSeconds);
        const stalenessRate = new Decimal(oracleParams.stalenessConfRateBps).div(new Decimal(HUNDRED_PERCENT_BPS));
        const inflateFactor = new Decimal(1).add(deltaT.mul(stalenessRate));
        cf = cf.mul(inflateFactor);

        let validated: boolean = true;
        // === 2. Validate confidence threshold ===
        // confidence / price * 10_000 < confThreshBps
        const confRatioBps = cf.div(pr).mul(new Decimal(HUNDRED_PERCENT_BPS));
        if (confRatioBps.gt(new Decimal(oracleParams.confThreshBps)))
          validated = false;

        // === 3. Validate staleness threshold ===
        if (deltaTBN.gt(oracleParams.stalenessThresh))
            validated = false;

        // === 4. Validate volatility threshold using EMA and price ===
        // max(ema, price) / min(ema, price) * 10_000 < volatilityThreshBps
        const maxPrice = Decimal.max(ema, pr);
        const minPrice = Decimal.min(ema, pr);
        if (!minPrice.eq(0)) {
          const volRatio = maxPrice.sub(minPrice).div(minPrice);
          const volRatioBps = volRatio.mul(new Decimal(HUNDRED_PERCENT_BPS));
          if (volRatioBps.gt(new Decimal(oracleParams.volatilityThreshBps))) {
              validated = false;
          }
        } else {
            validated = false;
        }

        // we don't validate liquidity for Pyth

        return new OraclePrice(
            pr,
            cf,
            parseInt(state.priceMessage.publishTime.toString()),
            validated
        );

    }

    

    // async fetchPriceFromHermes(priceFeedId: string): Promise<PythState> {
    //     const priceUpdate = await this.priceClient.getLatestPriceUpdates([priceFeedId], {encoding: "base64"});
    //     if(priceUpdate && priceUpdate.parsed && priceUpdate.parsed.length > 0) {
    //         const priceData = priceUpdate.parsed[0].price;
    //         return {
    //             price: new BN(priceData.price),
    //             conf: new BN(priceData.conf),
    //             expo: priceData.expo,
    //             publishTime: new BN(priceData.publishTime)
    //         };
    //     } else {
    //         throw new Error(`Failed to fetch price update from Hermes for ${priceFeedId}`);
    //     }
    // }

    // /**
    // * Should set feedId before running this
    // * @param {number} shardId - between 0-2^64, default is 0
    // * @param {number} [computeUnitPrice] - compute unit price in microlamports, default is 100_000
    // */
    // async updateFeedTx(wallet: any, shardId: number = 0, computeUnitPrice: number = 100000) {
    //     if(!shardId) shardId = 0;
    //     if(!computeUnitPrice) computeUnitPrice = 100000;
    //     let priceUpdate = await this.priceClient.getLatestPriceUpdates([this.priceFeedId], {encoding: "base64"});
    //     const pythSolanaReceiver = new PythSolanaReceiver({
    //         connection: this.connection,
    //         wallet: wallet,
    //     });
    //     const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({
    //         // closeUpdateAccounts: false
    //     });
    //     await transactionBuilder.addUpdatePriceFeed(priceUpdate.binary.data, shardId);
    //     let build = await transactionBuilder.buildVersionedTransactions({
    //         computeUnitPriceMicroLamports: computeUnitPrice,
    //     });

    //     return build;
    // };

    // async sendUpdateTx(
    //     provider: AnchorProvider,
    //     updateFeedTx: {
    //             tx: VersionedTransaction;
    //             signers: Signer[];
    //     }[] 
    // ): Promise<TransactionSignature[]>{

    //     let txs = await provider.sendAll(updateFeedTx, { skipPreflight: true,  commitment: "confirmed"});
    //     return txs;
    // }

    
}