use borsh::BorshDeserialize;
use num_traits::FromPrimitive;
use solana_program::{
    account_info::AccountInfo, entrypoint::ProgramResult, msg, program_error::ProgramError,
    pubkey::Pubkey,
};

use crate::instruction::ProgramInstruction;

pub mod activate_stake_pool;
pub mod add_to_bond_v2;
pub mod admin_freeze;
pub mod admin_mint;
pub mod admin_setup_fee_split;
pub mod change_central_state_authority;
pub mod change_inflation;
pub mod change_pool_minimum;
pub mod change_pool_multiplier;
pub mod claim_bond;
pub mod claim_bond_rewards;
pub mod claim_bond_v2_rewards;
pub mod claim_pool_rewards;
pub mod claim_rewards;
pub mod close_stake_account;
pub mod close_stake_pool;
pub mod crank;
pub mod create_bond;
pub mod create_bond_v2;
pub mod create_central_state;
pub mod create_stake_account;
pub mod create_stake_pool;
pub mod distribute_fees;
pub mod edit_metadata;
pub mod sign_bond;
pub mod stake;
pub mod unlock_bond_tokens;
pub mod unlock_bond_v2;
pub mod unstake;
pub mod admin_set_protocol_fee;
pub mod migrate_central_state_v2;
pub mod admin_program_freeze;
pub mod admin_renounce;
pub mod admin_change_freeze_authority;
pub mod create_royalty_account;
pub mod close_royalty_account;
pub mod cpi_claim_rewards;
pub mod cpi_claim_bond_v2_rewards;

pub struct Processor {}

impl Processor {
    pub fn process_instruction(
        program_id: &Pubkey,
        accounts: &[AccountInfo],
        instruction_data: &[u8],
    ) -> ProgramResult {
        msg!("Beginning processing");
        let instruction = FromPrimitive::from_u8(instruction_data[0])
            .ok_or(ProgramError::InvalidInstructionData)?;
        let instruction_data = &instruction_data[1..];
        msg!("Instruction unpacked");

        match instruction {
            ProgramInstruction::CreateCentralState => {
                msg!("Instruction: Create central state");
                let params = create_central_state::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_central_state::process_create_central_state(program_id, accounts, params)?;
            }
            ProgramInstruction::CreateStakePool => {
                msg!("Instruction: Create stake pool");
                let params = create_stake_pool::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_stake_pool::process_create_stake_pool(program_id, accounts, params)?;
            }
            ProgramInstruction::ActivateStakePool => {
                msg!("Instruction: Activate stake pool");
                activate_stake_pool::process_activate_stake_pool(program_id, accounts)?;
            }
            ProgramInstruction::CreateStakeAccount => {
                msg!("Instruction: Create stake account");
                let params = create_stake_account::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_stake_account::process_create_stake_account(program_id, accounts, params)?;
            }
            ProgramInstruction::Stake => {
                msg!("Instruction: Stake");
                let params = stake::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                stake::process_stake(program_id, accounts, params)?;
            }
            ProgramInstruction::Unstake => {
                msg!("Instruction: Unstake");
                let params = unstake::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                unstake::process_unstake(program_id, accounts, params)?;
            }
            ProgramInstruction::ClaimPoolRewards => {
                msg!("Instruction: Claim pool rewards");
                let params = claim_pool_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                claim_pool_rewards::process_claim_pool_rewards(program_id, accounts, params)?;
            }
            ProgramInstruction::ClaimRewards => {
                msg!("Instruction: Claim rewards");
                let params = claim_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                claim_rewards::process_claim_rewards(program_id, accounts, params)?;
            }
            ProgramInstruction::Crank => {
                msg!("Instruction: Crank");
                let params = crank::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                crank::process_crank(program_id, accounts, params)?;
            }
            ProgramInstruction::CloseStakePool => {
                msg!("Instruction: Close stake pool");
                let params = close_stake_pool::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                close_stake_pool::process_close_stake_pool(program_id, accounts, params)?;
            }
            ProgramInstruction::CloseStakeAccount => {
                msg!("Instruction: Close stake account");
                close_stake_account::process_close_stake_account(program_id, accounts)?;
            }
            ProgramInstruction::ChangeInflation => {
                msg!("Instruction: Change inflation rate");
                let params = change_inflation::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                change_inflation::process_change_inflation(program_id, accounts, params)?;
            }
            ProgramInstruction::CreateBond => {
                msg!("Instruction: create bond");
                let params = create_bond::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_bond::process_create_bond(program_id, accounts, params)?;
            }
            ProgramInstruction::SignBond => {
                msg!("Instruction: sign bond");
                let params = sign_bond::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                sign_bond::process_sign_bond(program_id, accounts, params)?;
            }
            ProgramInstruction::UnlockBondTokens => {
                msg!("Instruction: unlock bond token");
                let params = unlock_bond_tokens::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                unlock_bond_tokens::process_unlock_bond_tokens(program_id, accounts, params)?;
            }
            ProgramInstruction::ClaimBond => {
                msg!("Instruction: claim bond");
                let params = claim_bond::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                claim_bond::process_claim_bond(program_id, accounts, params)?;
            }
            ProgramInstruction::ClaimBondRewards => {
                msg!("Instruction: claim bond rewards");
                let params = claim_bond_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                claim_bond_rewards::process_claim_bond_rewards(program_id, accounts, params)?;
            }
            ProgramInstruction::ChangePoolMinimum => {
                msg!("Instruction: Change pool minimum");
                let params = change_pool_minimum::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                change_pool_minimum::process_change_pool_minimum(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminMint => {
                msg!("Instruction: Mint ACCESS tokens");
                let params = admin_mint::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_mint::process_admin_mint(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminFreeze => {
                msg!("Instruction: Admin freeze");
                admin_freeze::process_admin_freeze(program_id, accounts)?;
            }
            ProgramInstruction::ChangePoolMultiplier => {
                msg!("Instruction: Change pool multiplier");
                let params = change_pool_multiplier::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                change_pool_multiplier::process_change_pool_multiplier(
                    program_id, accounts, params,
                )?;
            }
            ProgramInstruction::ChangeCentralStateAuthority => {
                msg!("Instruction: Change central state authority");
                let params =
                    change_central_state_authority::Params::try_from_slice(instruction_data)
                        .map_err(|_| ProgramError::InvalidInstructionData)?;
                change_central_state_authority::process_change_central_state_auth(
                    program_id, accounts, params,
                )?;
            }
            ProgramInstruction::EditMetadata => {
                msg!("Instruction: Edit Access token metadata");
                let params = edit_metadata::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                edit_metadata::process_edit_metadata(program_id, accounts, params)?;
            }
            ProgramInstruction::CreateBondV2 => {
                msg!("Instruction: Create bond V2");
                let params = create_bond_v2::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_bond_v2::process_create_bond_v2(program_id, accounts, params)?;
            }
            ProgramInstruction::AddToBondV2 => {
                msg!("Instruction: Add to bond V2");
                let params = add_to_bond_v2::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                add_to_bond_v2::process_add_to_bond_v2(program_id, accounts, params)?;
            }
            ProgramInstruction::ClaimBondV2Rewards => {
                msg!("Instruction: Claim bond V2 rewards");
                let params = claim_bond_v2_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                claim_bond_v2_rewards::process_claim_bond_v2_rewards(program_id, accounts, params)?;
            }
            ProgramInstruction::UnlockBondV2 => {
                msg!("Instruction: Unlock bond V2");
                let params = unlock_bond_v2::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                unlock_bond_v2::process_unlock_bond_v2(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminSetupFeeSplit => {
                msg!("Instruction: Admin setup fee split");
                let params = admin_setup_fee_split::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_setup_fee_split::process_admin_setup_fee_split(program_id, accounts, params)?;
            }
            ProgramInstruction::DistributeFees => {
                msg!("Instruction: Distribute fees");
                let params = distribute_fees::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                distribute_fees::process_distribute_fees(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminSetProtocolFee => {
                msg!("Instruction: Admin set protocol fee");
                let params = admin_set_protocol_fee::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_set_protocol_fee::process_admin_set_protocol_fee(program_id, accounts, params)?;
            }
            ProgramInstruction::MigrateCentralStateV2 => {
                msg!("Instruction: Migrate central state V2");
                let params = migrate_central_state_v2::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                migrate_central_state_v2::process_migrate_central_state_v2(
                    program_id, accounts, params,
                )?;
            }
            ProgramInstruction::AdminProgramFreeze => {
                msg!("Instruction: Admin program freeze");
                let params = admin_program_freeze::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_program_freeze::process_admin_program_freeze(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminRenounce => {
                msg!("Instruction: Admin renounce");
                let params = admin_renounce::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_renounce::process_admin_renounce(program_id, accounts, params)?;
            }
            ProgramInstruction::AdminChangeFreezeAuthority => {
                msg!("Instruction: Admin change freeze authority");
                let params = admin_change_freeze_authority::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                admin_change_freeze_authority::process_admin_change_freeze_authority(
                    program_id, accounts, params,
                )?;
            }
            ProgramInstruction::CreateRoyaltyAccount => {
                msg!("Instruction: Create royalty account");
                let params = create_royalty_account::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                create_royalty_account::process_create_royalty_account(program_id, accounts, params)?;
            }
            ProgramInstruction::CloseRoyaltyAccount => {
                msg!("Instruction: Close royalty account");
                close_royalty_account::process_close_royalty_account(program_id, accounts)?;
            }
            ProgramInstruction::CpiClaimRewards => {
                msg!("Instruction: CPI claim rewards");
                let params = cpi_claim_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                cpi_claim_rewards::process_cpi_claim_rewards(program_id, accounts, params)?;
            }
            ProgramInstruction::CpiClaimBondV2Rewards => {
                msg!("Instruction: CPI claim bond V2 rewards");
                let params = cpi_claim_bond_v2_rewards::Params::try_from_slice(instruction_data)
                    .map_err(|_| ProgramError::InvalidInstructionData)?;
                cpi_claim_bond_v2_rewards::process_cpi_claim_bond_v2_rewards(
                    program_id, accounts, params,
                )?;
            }
        }

        Ok(())
    }
}