pub mod assertions;
pub mod constants;
pub mod errors;
pub mod instructions;
pub mod state;

use {
    anchor_lang::prelude::*,
    instructions::*,
    state::{DelegateAuthority, Project, SerializableActions},
};

declare_id!("HivezrprVqHR6APKKQkkLHmUG8waZorXexEBRZWh5LRm");

fn profile_platform_gate<'info>(
    project: &Account<'info, Project>,
    signer_key: Pubkey,
    payer: AccountInfo<'info>,
    vault: AccountInfo<'info>,
    delegate_authority: &Option<Account<'info, DelegateAuthority>>,
    system_program: AccountInfo<'info>,
    instructions_sysvar: AccountInfo<'info>,
) -> Result<()> {
    if signer_key.eq(&project.driver) {
        msg!("Driver action");
        instructions::platform_gate_fn(
            SerializableActions::DriverAction,
            Some((0, Pubkey::default())),
            project,
            signer_key,
            payer,
            vault,
            delegate_authority,
            system_program,
            instructions_sysvar,
            ID,
        )
    } else {
        instructions::platform_gate_fn(
            SerializableActions::PublicLow,
            None,
            project,
            signer_key,
            payer,
            vault,
            delegate_authority,
            system_program,
            instructions_sysvar,
            ID,
        )
    }
}

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

    /// This function initializes the public information for the Honeycomb Protocol.
    /// It is called when the program is deployed and can be accessed by only the program authority.
    pub fn init_public_info(ctx: Context<InitPublicInfo>, env: String) -> Result<()> {
        assertions::assert_program_authority(
            ctx.accounts.program.to_account_info(),
            ctx.accounts.program_data.to_account_info(),
            ctx.accounts.authority.key,
        )?;
        instructions::init_public_info(ctx, env)
    }

    /// This function sets the public information for the Honeycomb Protocol.
    /// It is called when the program authority needs to update the public information.
    pub fn set_public_info(
        ctx: Context<SetPublicInfo>,
        env: String,
        args: SetPublicInfoArgs,
    ) -> Result<()> {
        assertions::assert_program_authority(
            ctx.accounts.program.to_account_info(),
            ctx.accounts.program_data.to_account_info(),
            ctx.accounts.authority.key,
        )?;
        instructions::set_public_info(ctx, env, args)
    }

    /// Sets the authentication driver with the provided environment string and arguments.
    ///
    /// This function sets the authentication driver for the Honeycomb Protocol.
    /// It is called when the program authority needs to update the authentication driver.
    pub fn set_auth_driver(
        ctx: Context<SetAuthDriver>,
        env: String,
        args: SetAuthDriverArgs,
    ) -> Result<()> {
        assertions::assert_program_authority(
            ctx.accounts.program.to_account_info(),
            ctx.accounts.program_data.to_account_info(),
            ctx.accounts.authority.key,
        )?;
        instructions::set_auth_driver(ctx, env, args)
    }

    pub fn platform_gate(ctx: Context<PlatformGate>, args: PlatformGateArgs) -> Result<()> {
        instructions::platform_gate(ctx, args)
    }

    /// This function creates a new project in the Honeycomb Protocol.
    pub fn create_project(ctx: Context<CreateProject>, args: CreateProjectArgs) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::CreateProject,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &None,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::create_project(ctx, args)
    }

    /// This function changes the driver authority for the specified project in the Honeycomb Protocol.
    pub fn change_driver(ctx: Context<ChangeDriver>) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageDelegateAuthority,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::change_driver(ctx)
    }

    /// This function changes the driver authority for the specified project in the Honeycomb Protocol.
    pub fn add_remove_criteria(
        ctx: Context<AddRemoveCriteria>,
        args: AddRemoveCriteriaArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageCriterias,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::add_remove_criteria(ctx, args)
    }

    /// This function adds or removes a criteria to/from the specified project in the Honeycomb Protocol.
    pub fn add_remove_service(
        ctx: Context<AddRemoveService>,
        args: AddRemoveServiceArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            if args.remove.unwrap_or(false) {
                SerializableActions::RemoveService
            } else {
                SerializableActions::AddService
            },
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::add_remove_service(ctx, args)
    }

    /// This function adds or removes a service to/from the specified project in the Honeycomb Protocol.
    pub fn add_remove_profile_data_config(
        ctx: Context<AddRemoveProfileDataConfig>,
        args: AddRemoveProfileDataConfigArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageProfiles,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::add_remove_profile_data_config(ctx, args)
    }

    /// This function clears the profile data configuration for the specified project in the Honeycomb Protocol.
    pub fn clear_profile_data_config(ctx: Context<ClearProfileDataConfig>) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageProfiles,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::clear_profile_data_config(ctx)
    }

    /// This function adds an address container to the specified project in the Honeycomb Protocol.
    pub fn add_address_container_to_project(
        ctx: Context<AddAddressContainerToProject>,
        args: AddAddressContainerToProjectArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageIndexing,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &ctx.accounts.delegate_authority,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::add_address_container_to_project(ctx, args)
    }

    /// This function adds multiple mint addresses to the specified address container in the Honeycomb Protocol.
    pub fn add_mint_addresses_to_address_container(
        ctx: Context<AddMintAddressesToAddressContainer>,
        args: AddMintAddressesToAddressContainerArgs,
    ) -> Result<()> {
        instructions::add_mint_addresses_to_address_container(ctx, args)
    }

    /// This function adds multiple mint addresses to the specified address container in the Honeycomb Protocol.
    pub fn create_delegate_authority(
        ctx: Context<CreateDelegateAuthority>,
        args: CreateDelegateAuthorityArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageDelegateAuthority,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &None,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::create_delegate_authority(ctx, args)
    }

    /// This function adds or removes a delegation for the specified project in the Honeycomb Protocol.
    pub fn add_remove_delegation(
        ctx: Context<ModifyDelegate>,
        args: AddRemoveDelegationArgs,
    ) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::ManageDelegateAuthority,
            None,
            &ctx.accounts.project,
            ctx.accounts.authority.key(),
            ctx.accounts.payer.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &None,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::add_remove_delegation(ctx, args)
    }

    /// This function registers a new user in the Honeycomb Protocol.
    pub fn initialize_user(ctx: Context<InitializeUser>, args: InitializeUserArgs) -> Result<()> {
        instructions::initialize_user(ctx, args)
    }

    /// This function closes an existing user in the HPL Hive Control program.
    pub fn close_user(ctx: Context<CloseUser>) -> Result<()> {
        instructions::close_user(ctx)
    }

    /// This function updates user info in the HPL Hive Control program.
    pub fn update_user(ctx: Context<UpdateUser>, env: String, args: UpdateUserArgs) -> Result<()> {
        let assert_user = assertions::assert_user(&ctx.accounts.user, ctx.accounts.authority.key());
        if assert_user.is_err() {
            assertions::assert_auth_driver(&ctx.accounts.public_info, &ctx.accounts.authority)?;
        }

        instructions::update_user(ctx, env, args)
    }

    /// This function adds a new wallet to the user's profile in the HPL Hive Control program.
    pub fn add_wallet(ctx: Context<AddWallet>, env: String) -> Result<()> {
        let assert_user = assertions::assert_user(&ctx.accounts.user, ctx.accounts.authority.key());
        if assert_user.is_err() {
            assertions::assert_auth_driver(&ctx.accounts.public_info, &ctx.accounts.authority)?;
        }

        instructions::add_wallet(ctx, env)
    }

    /// This function deletes a wallet from the user's profile in the HPL Hive Control program.
    pub fn delete_wallet(ctx: Context<DeleteWallet>, env: String) -> Result<()> {
        let assert_user = assertions::assert_user(&ctx.accounts.user, ctx.accounts.authority.key());
        if assert_user.is_err() {
            assertions::assert_auth_driver(&ctx.accounts.public_info, &ctx.accounts.authority)?;
        }

        instructions::delete_wallet(ctx, env)
    }

    /// This function creates a new profile for qthe user in the HPL Hive Control program.
    pub fn create_profile(ctx: Context<CreateProfile>, args: CreateProfileArgs) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::PublicLow,
            None,
            &ctx.accounts.project,
            ctx.accounts.wallet.key(),
            ctx.accounts.wallet.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &None,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::create_profile(ctx, args)
    }

    /// This function deletes the user's profile in the HPL Hive Control program.
    pub fn delete_profile(ctx: Context<DeleteProfile>) -> Result<()> {
        instructions::platform_gate_fn(
            SerializableActions::PublicLow,
            None,
            &ctx.accounts.project,
            ctx.accounts.wallet.key(),
            ctx.accounts.wallet.to_account_info(),
            ctx.accounts.vault.to_account_info(),
            &None,
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.instructions_sysvar.to_account_info(),
            ID,
        )?;

        instructions::delete_profile(ctx)
    }

    /// This function adds profile data to the user's profile in the HPL Hive Control program.
    pub fn manage_profile_data(
        ctx: Context<ManageProfileData>,
        args: ManageProfileDataArgs,
    ) -> Result<()> {
        if args.value.is_some() {
            profile_platform_gate(
                &ctx.accounts.project,
                ctx.accounts.authority.key(),
                ctx.accounts.payer.to_account_info(),
                ctx.accounts.vault.to_account_info(),
                &ctx.accounts.delegate_authority,
                ctx.accounts.system_program.to_account_info(),
                ctx.accounts.instructions_sysvar.to_account_info(),
            )?;
        }

        instructions::manage_profile_data(ctx, args)
    }

    pub fn migrate_account(ctx: Context<MigrateAccount>, args: MigrateAccountArgs) -> Result<()> {
        instructions::migrate_account(ctx, args)
    }

    pub fn close_orphan_wallet_resolver(ctx: Context<CloseOrphanWalletResolver>) -> Result<()> {
        instructions::close_orphan_wallet_resolver(ctx)
    }
}