#![cfg_attr(feature = "no-entrypoint", allow(dead_code))]
// #![feature(trivial_bounds)]

use anchor_lang::prelude::*;
use solana_program::pubkey::Pubkey;

use instructions::*;
use solana_security_txt::security_txt;
pub mod errors;
pub mod instructions;
pub mod state;
pub mod utils;

declare_id!("JAiLsp5k6ANQAy9UcJC9TfTWieY5Afo42ykihpTeVk8L");
// declare_id!("5ai4CtMebtFxvgK6fDJXfSGn9K6aLbRe1uxxToZWt9dR");

#[cfg(not(feature = "no-entrypoint"))]
security_txt! {
    name: "Fracture Staking",
    project_url: "https://thefracture.io/",
    contacts: "email:dev@thefracture.io,twitter:@TheFracture_",
    policy: "private",
    preferred_languages: "en",
    source_code: "private"
}

#[program]
mod jungle {
    use super::*;

    /// Initializes the jungle
    pub fn initialize_jungle(
        ctx: Context<InitializeJungle>,
        bumps: InitializeJungleBumps,
        maximum_weekly_multiplier: u64,
        weekly_multiplier: u64,
        maximum_holdings_multiplier: u64,
        holdings_multiplier: u64,
        start: i64,
        root: [u8; 32],
    ) -> Result<()> {
        instructions::init_jungle::handler(
            ctx,
            bumps,
            maximum_weekly_multiplier,
            weekly_multiplier,
            maximum_holdings_multiplier,
            holdings_multiplier,
            start,
            root,
        )
    }

    /// Sets the jungle parameters
    pub fn set_jungle(
        ctx: Context<SetJungle>,
        maximum_weekly_multiplier: u64,
        weekly_multiplier: u64,
        maximum_holdings_multiplier: u64,
        holdings_multiplier: u64,
        start: i64,
        root: [u8; 32],
    ) -> Result<()> {
        instructions::set_jungle::handler(
            ctx,
            maximum_weekly_multiplier,
            weekly_multiplier,
            maximum_holdings_multiplier,
            holdings_multiplier,
            start,
            root,
        )
    }

    /// New Dummy Animal
    pub fn init_dummy(ctx: Context<InitDummy>, bump: u8) -> Result<()> {
        instructions::init_dummy::handler(ctx, bump)
    }

    /// Add Reward Token
    pub fn add_reward_token(
        ctx: Context<AddRewardToken>,
        bumps: u8,
        decimals: u8,
        value: u64,
    ) -> Result<()> {
        instructions::add_reward_token::handler(ctx, bumps, decimals, value)
    }

    /// Update Reward Token
    pub fn update_reward_token(
        ctx: Context<UpdateRewardToken>,
        decimals: u8,
        value: u64,
    ) -> Result<()> {
        instructions::update_reward_token::handler(ctx, decimals, value)
    }

    /// Init Staker
    pub fn init_staker(ctx: Context<InitStaker>, bumps: u8) -> Result<()> {
        instructions::init_staker::handler(ctx, bumps)
    }

    /// Init Transaction Batch
    pub fn init_transaction_batch(ctx: Context<InitTransactionBatch>) -> Result<()> {
        instructions::init_transaction_batch::handler(ctx)
    }

    /// Stake an animal
    pub fn stake_animal<'info>(
        ctx: Context<'_, '_, '_, 'info, StakeAnimal<'info>>,
        bumps: StakeAnimalBumps,
        // proof: Vec<CompressedProofElement>,
        emissions_per_day: u64,
        faction: u64,
        // authorization_data: Option<AuthorizationDataLocal>,
        rules_acc_present: bool,
    ) -> Result<()> {
        instructions::stake_animal::handler(
            ctx,
            bumps,
            // proof,
            emissions_per_day,
            faction,
            // authorization_data,
            rules_acc_present,
        )
    }

    /// Unstake a staked animal
    pub fn unstake_animal<'info>(
        ctx: Context<'_, '_, '_, 'info, UnstakeAnimal<'info>>,
        authorization_data: Option<AuthorizationDataLocal>,
        rules_acc_present: bool,
    ) -> Result<()> {
        instructions::unstake_animal::handler(ctx, authorization_data, rules_acc_present)
    }

    /// Claim staking rewards
    pub fn claim_staking(ctx: Context<ClaimStaking>) -> Result<()> {
        instructions::claim_staking::handler(ctx)
    }

    /// Bulk Claim
    pub fn bulk_claim(ctx: Context<BulkClaim>) -> Result<()> {
        instructions::bulk_claim::handler(ctx)
    }

    /// Withdraw rewards from the vault
    pub fn swap_points(ctx: Context<SwapPoints>, amount: u64) -> Result<()> {
        instructions::swap_points::handler(ctx, amount)
    }

    /// Burn points from the vault
    pub fn burn_points(ctx: Context<BurnPoints>, amount: u64) -> Result<()> {
        instructions::burn_points::handler(ctx, amount)
    }
    /// Burn points from the vault
    // pub fn fix_bridged(
    //     ctx: Context<FixBridged>,
    //     transaction_index: u32
    // ) -> Result<()> {
    //     instructions::fix_bridged::handler(
    //         ctx,
    //         transaction_index
    //     )
    // }
    /// Transfer Point to someone
    pub fn transfer_points(ctx: Context<TransferPoints>, amount: u64) -> Result<()> {
        instructions::transfer_points::handler(ctx, amount)
    }

    /// Reward Point to staker
    pub fn reward_points(ctx: Context<RewardPoints>, amount: u64) -> Result<()> {
        instructions::reward_point::handler(ctx, amount)
    }

    /// Unstake a staked animal
    pub fn force_unstake<'info>(
        ctx: Context<'_, '_, '_, 'info, ForceUnstake<'info>>,
        authorization_data: Option<AuthorizationDataLocal>,
        rules_acc_present: bool,
    ) -> Result<()> {
        instructions::force_unstake::handler(ctx, authorization_data, rules_acc_present)
    }

    // /// Initialize admin
    // pub fn init_admin(ctx: Context<InitAdmin>, bump: u8) -> Result<()> {
    //     instructions::init_admin::handler(ctx, bump)
    // }
}

#[account]
pub struct Admin {
    pub bump: u8,
    pub jungle_key: Pubkey,
}
impl Admin {
    pub const LEN: usize = 8 + 1 + 32;
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]
pub struct InitializeJungleBumps {
    pub jungle: u8,
    pub escrow: u8,
}
/// The global state of the program
#[account]
#[derive(Default)]
pub struct Jungle {
    /// The identifier
    pub key: Pubkey,

    /// The owner of the program
    pub owner: Pubkey,

    /// The bump used to generate PDAs
    pub bumps: InitializeJungleBumps,

    /// The PDA owning the community fund
    pub escrow: Pubkey,

    /// Array of rewards tokens mint
    pub reward_tokens: Vec<Reward>,

    /// The total animals currently staked.
    pub animals_staked: u64,

    // Maximum Weekly Multiplier
    pub maximum_weekly_multiplier: u64,

    // Base Weekly Multiplier
    pub weekly_multiplier: u64,

    // Maximum Holdings Multiplier
    pub maximum_holdings_multiplier: u64,

    // Base Holdings Multiplier
    pub holdings_multiplier: u64,

    /// The time the staking starts (in seconds since 1970)
    pub start: i64,

    /// The root of the merkle tree used to know if a token is part of the collection
    pub root: [u8; 32],
}

#[derive(AnchorSerialize, AnchorDeserialize, Copy, Clone, Default)]
pub struct Reward {
    /// Bumps used to create associated token account
    pub bumps: u8,

    /// Mint of the reward token
    pub mint: Pubkey,

    /// The account associated to the reward token
    pub account: Pubkey,

    /// Decimal points of the reward token
    pub decimals: u8,

    /// Points -> Token Worth
    pub value: u64,
}
impl Reward {
    pub const LEN: usize = 8 + 40 + 40 + 1 + 8;
}

#[derive(AnchorSerialize, AnchorDeserialize, Copy, Clone, Default)]
pub struct StakeAnimalBumps {
    pub animal: u8,
    pub deposit: u8,
    pub staker_info: u8,
}

/// The staking account linked to the NFT
#[account]
#[derive(Default)]
pub struct Animal {
    /// Bump used to create this PDA
    pub bumps: StakeAnimalBumps,

    /// The mint of the NFT
    pub mint: Pubkey,

    /// Owner of the animal
    pub staker: Pubkey,

    /// How rare the animal is
    pub emissions_per_day: u64,

    /// The wallet to which fees are given
    pub faction: u8,

    /// Last time the owner claimed rewards
    pub last_claim: i64,

    /// Last time the owner claimed rewards
    pub staked_at: i64,
}

impl Animal {
    pub const LEN: usize = 8 + 2 + 40 + 40 + 8 + 1 + 8 + 8;
}

#[account]
#[derive(Default)]
pub struct StakerInfo {
    /// Bumps used to create this PDA
    pub bumps: u8,

    /// Staker Account
    pub staker: Pubkey,

    /// Number of animals staked
    pub holdings: u64,

    /// Pending Rewards
    pub tokens: u64,
    // /// Transaction History
    // pub transaction_batches: Vec<Pubkey>,
}
impl StakerInfo {
    pub const LEN: usize = 8 + 1 + 40 + 8 + 8 + 40 * 254; // 10225
}

#[account]
#[derive(Default)]
pub struct TransactionBatch {
    /// Authority to change
    pub staker: Pubkey,

    /// Transaction History
    pub transactions: Vec<Transaction>,
}
impl TransactionBatch {
    pub const LEN: usize = 8 + 40 + Transaction::LEN * 254; // 10208
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]
pub struct Transaction {
    pub timestamp: i64,      // seconds since 1970
    pub amount: u64,         // amount of tokens
    pub description: String, // rewards claimed, paid for InAppPurchase etc
}

impl Transaction {
    pub const LEN: usize = 8 + 8 + 24; // 40
}