// programs/jaynes/src/lib.rs
// jaynes — token-2022 transfer hook, solana mainnet
// maintains a 256-bin discrete posterior over the token's true price
// and updates it via the full bayesian rule on every swap. fixed-point i128.
// on every entropy increase, appends a surprise record to an on-chain log.
// no admin, no upgrade, no team allocation, no parameter ever changed.

use anchor_lang::prelude::*;
use anchor_spl::token_interface::{Mint, TokenAccount};
use spl_tlv_account_resolution::{
    account::ExtraAccountMeta, seeds::Seed, state::ExtraAccountMetaList,
};
use spl_transfer_hook_interface::instruction::{
    ExecuteInstruction, TransferHookInstruction,
};

declare_id!("JayneSLogicScienceProgRamAddRess111111111111");

// ——— constants ——————————————————

const BINS:            usize = 256;
const FP_SCALE:        i128  = 1_000_000_000_000;        // 1e12 fixed-point
const H_MAX_FP:        i128  = 8_000_000_000_000;        // log2(256) × 1e12
const H_FLOOR_FP:      i128  = 1_000_000_000_000;        // 1 bit · irreducible humility
const SIGMA_FP:        i128  =     8_000_000_000;        // gaussian width, ~3 bins
const SURPRISE_THRESH: i128  =    20_000_000_000;        // 0.02 bits ΔH
const PRICE_LO_FP:     i128  =    10_000_000_000;        // 0.001  · range floor
const PRICE_HI_FP:     i128  = 3_000_000_000_000;        // 0.003  · range ceiling

// ——— account layout ————————————————

#[account]
pub struct Posterior {
    pub mint:            Pubkey,
    pub dlmm_pool:       Pubkey,
    pub updates:         u64,
    pub last_entropy_fp: i128,
    pub last_map_idx:    u16,
    // the posterior itself, normalised to sum to FP_SCALE
    pub p_fp:            [i128; BINS],
}

#[account]
pub struct SurpriseLogHeader {
    pub mint:    Pubkey,
    pub count:   u64,
    pub bump:    u8,
    // records follow this header in the same account, fixed stride
}

#[account(zero_copy)]
pub struct SurpriseRecord {
    pub slot:           u64,
    pub prior_map_idx:  u16,
    pub post_map_idx:   u16,
    pub delta_h_fp:     i128,
    pub trade_price_fp: i128,
    pub trade_size:     u64,
}

// ——— execute: transfer hook entrypoint —————————
//
// token-2022 invokes this on every transfer of the jaynes mint.
// on a meteora dlmm swap the call path is:
//
//   user → dlmm::swap → token_2022::transfer → jaynes::execute
//
// the hook does not return a surcharge. it returns zero. all that happens
// is a posterior update, fully visible to anyone who reads the pda.

#[derive(Accounts)]
pub struct Execute<'info> {
    pub source:       InterfaceAccount<'info, TokenAccount>,
    pub mint:         InterfaceAccount<'info, Mint>,
    pub destination:  InterfaceAccount<'info, TokenAccount>,
    /// CHECK: meteora dlmm pool, read-only, validated against posterior.dlmm_pool
    pub dlmm_pool:    AccountInfo<'info>,
    #[account(
        mut,
        seeds = [b"posterior", mint.key().as_ref()],
        bump,
        constraint = posterior.dlmm_pool == dlmm_pool.key(),
    )]
    pub posterior:    Account<'info, Posterior>,
    #[account(
        mut,
        seeds = [b"surprises", mint.key().as_ref()],
        bump = log_header.bump,
    )]
    pub log_header:   Account<'info, SurpriseLogHeader>,
}

#[program]
pub mod jaynes {
    use super::*;

    pub fn execute(ctx: Context<Execute>, amount: u64) -> Result<u64> {
        let clock = Clock::get()?;
        let post  = &mut ctx.accounts.posterior;

        // 1. read the swap's executed price from the dlmm pool's active bin
        let (_bin_id, trade_price_fp) = read_active_bin(&ctx.accounts.dlmm_pool)?;

        // 2. snapshot prior entropy and prior MAP
        let prior_h_fp   = post.last_entropy_fp;
        let prior_map    = post.last_map_idx;

        // 3. for each of the 256 hypothesised true prices, multiply prior
        //    by gaussian likelihood centred at the hypothesis
        for i in 0..BINS {
            let mu_fp   = bin_to_price_fp(i);
            let like_fp = gaussian_fp(trade_price_fp, mu_fp, SIGMA_FP);
            post.p_fp[i] = (post.p_fp[i] * like_fp) / FP_SCALE;
        }

        // 4. renormalise so the posterior sums to FP_SCALE exactly
        renormalise(&mut post.p_fp);

        // 5. compute new entropy and new MAP
        let new_h_fp   = entropy_fp(&post.p_fp);
        let new_h_fp   = new_h_fp.max(H_FLOOR_FP);
        let new_map    = argmax(&post.p_fp);

        post.last_entropy_fp = new_h_fp;
        post.last_map_idx    = new_map;
        post.updates        += 1;

        // 6. if entropy increased by more than the threshold, log a surprise
        let delta_h = new_h_fp - prior_h_fp;
        if delta_h > SURPRISE_THRESH {
            append_surprise(
                &mut ctx.accounts.log_header,
                SurpriseRecord {
                    slot:           clock.slot,
                    prior_map_idx:  prior_map,
                    post_map_idx:   new_map,
                    delta_h_fp:     delta_h,
                    trade_price_fp,
                    trade_size:     amount,
                },
            )?;
        }

        msg!(
            "jaynes: H={} ΔH={} MAP={} updates={}",
            new_h_fp, delta_h, new_map, post.updates,
        );

        // surcharge is always zero — the protocol does not charge
        Ok(0)
    }
}

// ——— bayesian internals ————————————————

fn bin_to_price_fp(i: usize) -> i128 {
    let w = (PRICE_HI_FP - PRICE_LO_FP) / (BINS as i128);
    PRICE_LO_FP + w * (i as i128)
}

fn gaussian_fp(x_fp: i128, mu_fp: i128, sigma_fp: i128) -> i128 {
    // exp(-(x-μ)² / 2σ²) in fixed-point via 5-term taylor expansion.
    // production builds swap this for a 256-entry lookup keyed by |x-μ|/σ.
    let d  = (x_fp - mu_fp) / 1_000_000;
    let v  = (d * d) / (2 * (sigma_fp / 1_000_000).pow(2));
    exp_neg_fp(v)
}

fn renormalise(p: &mut [i128; BINS]) {
    let mut sum: i128 = 0;
    for i in 0..BINS { sum = sum.saturating_add(p[i]); }
    if sum <= 0 { // degenerate, restore flat prior
        let uniform = FP_SCALE / (BINS as i128);
        for i in 0..BINS { p[i] = uniform; }
        return;
    }
    for i in 0..BINS {
        p[i] = (p[i] * FP_SCALE) / sum;
    }
}

fn entropy_fp(p: &[i128; BINS]) -> i128 {
    let mut h: i128 = 0;
    for i in 0..BINS {
        if p[i] <= 0 { continue; }
        let log2_p = log2_fp(p[i]);            // negative for p < 1
        h = h.saturating_sub((p[i] * log2_p) / FP_SCALE);
    }
    h
}

fn argmax(p: &[i128; BINS]) -> u16 {
    let mut best = 0i128; let mut idx = 0u16;
    for i in 0..BINS {
        if p[i] > best { best = p[i]; idx = i as u16; }
    }
    idx
}

// ——— surprise log ———————————————————

fn append_surprise(
    header: &mut Account<SurpriseLogHeader>,
    rec: SurpriseRecord,
) -> Result<()> {
    // records are written sequentially into the trailing region of the same
    // account. the program is configured at deployment with enough rent-paid
    // space for ~16,000 records; once full the program rejects further writes
    // and the protocol stops logging surprises (but continues to update).
    header.count = header.count.saturating_add(1);
    write_record_at(&mut header.to_account_info(), header.count - 1, rec)?;
    Ok(())
}

// ——— dlmm pool reader —————————————————
//
// identical to the reader used by other meteora-integrated hooks: active bin id
// at offset 88 (i32), bin step bps at offset 92 (u16), price reconstructed
// via exponentiation by squaring in i128 fixed-point.

fn read_active_bin(pool: &AccountInfo) -> Result<(i32, i128)> {
    let data = pool.try_borrow_data()?;
    require!(data.len() >= 96, ErrorCode::PoolAccountMalformed);
    let active_id = i32::from_le_bytes(data[88..92].try_into().unwrap());
    let bin_step  = u16::from_le_bytes(data[92..94].try_into().unwrap()) as i128;
    let base      = FP_SCALE + (bin_step * FP_SCALE) / 10_000;
    Ok((active_id, pow_fp(base, active_id)))
}

// helpers: pow_fp, exp_neg_fp, log2_fp, write_record_at — omitted for brevity.
// full source on github at /jaynes-protocol/jaynes

#[error_code]
pub enum ErrorCode {
    #[msg("dlmm pool account data is malformed or too short")]
    PoolAccountMalformed,
    #[msg("posterior account not initialised")]
    PosteriorUninitialised,
    #[msg("surprise log is full")]
    SurpriseLogFull,
}