use core::panic;

use {
    crate::state::*,
    anchor_lang::prelude::*,
    hpl_events::HplEvents,
    hpl_utils::{reallocate, traits::Default},
};

#[derive(Accounts)]
#[instruction(args: InitializeUserArgs)]
pub struct InitializeUser<'info> {
    /// The User accout
    #[account(
        init, payer = wallet,
        space = User::LEN,
        seeds = [b"user".as_ref(), args.username.as_bytes()],
        bump
    )]
    pub user: Account<'info, User>,

    /// The wallet resolver for the primary wallet
    #[account(
        init, payer = wallet,
        space = WalletResolver::LEN,
        seeds = [b"wallet_resolver".as_ref(), wallet.key().as_ref()],
        bump
    )]
    pub wallet_resolver: Account<'info, WalletResolver>,

    /// The primary wallet of the user
    #[account(mut)]
    pub wallet: Signer<'info>,

    /// System Program
    pub system_program: Program<'info, System>,

    /// NO OP program
    pub hpl_events: Program<'info, HplEvents>,

    /// NATIVE SYSVAR CLOCK
    pub clock: Sysvar<'info, Clock>,

    /// SYSVAR RENT ACCOUNT
    pub rent_sysvar: Sysvar<'info, Rent>,

    /// NATIVE INSTRUCTIONS SYSVAR
    /// CHECK: This is not dangerous because we don't read or write from this account
    #[account(address = anchor_lang::solana_program::sysvar::instructions::ID)]
    pub instructions_sysvar: AccountInfo<'info>,
}

/// Structure representing the arguments for initializing a user.
///
/// # Fields
///
/// - `username`: The username of the user to be initialized.
/// - `name`: The name of the user to be initialized.
/// - `bio`: The biography of the user to be initialized.
/// - `pfp`: The profile picture URL or identifier of the user to be initialized.
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, PartialEq)]
pub struct InitializeUserArgs {
    pub username: String,
    pub name: String,
    pub bio: String,
    pub pfp: String,
}

pub fn initialize_user(ctx: Context<InitializeUser>, args: InitializeUserArgs) -> Result<()> {
    let user = &mut ctx.accounts.user;
    user.set_defaults();

    let user_info = user.to_account_info();
    let mut diff: usize = 0;

    let username_len = args.username.as_bytes().len();
    if username_len > 24 {
        diff += username_len - 24;
    }

    let name_len = args.name.as_bytes().len();
    if name_len > 24 {
        diff += name_len - 24;
    }

    let bio_len = args.bio.as_bytes().len();
    if bio_len > 24 {
        diff += bio_len - 24;
    }

    let pfp_len = args.pfp.as_bytes().len();
    if pfp_len > 24 {
        diff += pfp_len - 24;
    }

    if diff > 0 {
        reallocate(
            diff as isize,
            user_info,
            ctx.accounts.wallet.to_account_info(),
            &ctx.accounts.rent_sysvar,
            &ctx.accounts.system_program,
        )?;
    }

    user.bump = ctx.bumps["user"];
    user.primary_wallet = ctx.accounts.wallet.key();
    user.username = args.username;
    user.name = args.name;
    user.bio = args.bio;
    user.pfp = args.pfp;

    let wallet_resolver = &mut ctx.accounts.wallet_resolver;
    wallet_resolver.set_defaults();
    wallet_resolver.bump = ctx.bumps["wallet_resolver"];
    wallet_resolver.user = user.key();
    wallet_resolver.wallet = ctx.accounts.wallet.key();

    Event::new_user(user.key(), user.try_to_vec().unwrap(), &ctx.accounts.clock)
        .emit(ctx.accounts.hpl_events.to_account_info())?;

    Ok(())
}

#[derive(Accounts)]
pub struct CloseUser<'info> {
    /// The user accout
    #[account(
        mut,
        close = wallet,
    )]
    pub user: Account<'info, User>,

    /// The wallet resolver of the primary wallet
    #[account(mut, has_one = user, close = wallet)]
    pub wallet_resolver: Account<'info, WalletResolver>,

    /// The primary wallet
    #[account(mut)]
    pub wallet: Signer<'info>,

    /// System Program
    pub system_program: Program<'info, System>,
}
pub fn close_user(_ctx: Context<CloseUser>) -> Result<()> {
    Ok(())
}

#[derive(Accounts)]
#[instruction(_env: String)]
pub struct UpdateUser<'info> {
    /// The public info account
    #[account(
        seeds = [b"public_info".as_ref(), _env.as_bytes(), crate::id().as_ref()],
        bump = public_info.bump,
      )]
    pub public_info: Account<'info, PublicInfo>,

    /// The user account
    #[account(mut)]
    pub user: Account<'info, User>,

    /// One of the user's wallet
    #[account(mut)]
    pub authority: Signer<'info>,

    /// NO OP program
    pub hpl_events: Program<'info, HplEvents>,

    /// NATIVE SYSVAR CLOCK
    pub clock: Sysvar<'info, Clock>,

    /// NATIVE INSTRUCTIONS SYSVAR
    /// CHECK: This is not dangerous because we don't read or write from this account
    #[account(address = anchor_lang::solana_program::sysvar::instructions::ID)]
    pub instructions_sysvar: AccountInfo<'info>,
}

/// Structure representing the arguments for updating a user.
///
/// # Fields
///
/// - `name`: [Option] new name for the user. If provided, the user's name will be updated.
/// - `bio`: [Option] new biography for the user. If provided, the user's biography will be updated.
/// - `pfp`: [Option] new profile picture URL for the user. If provided, the user's profile picture will be updated.
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, PartialEq)]
pub struct UpdateUserArgs {
    pub name: Option<String>,
    pub bio: Option<String>,
    pub pfp: Option<String>,
}

pub fn update_user(ctx: Context<UpdateUser>, _env: String, args: UpdateUserArgs) -> Result<()> {
    let user = &mut ctx.accounts.user;
    user.name = args.name.unwrap_or(user.name.clone());
    user.bio = args.bio.unwrap_or(user.bio.clone());
    user.pfp = args.pfp.unwrap_or(user.pfp.clone());

    Event::update_user(user.key(), user.try_to_vec().unwrap(), &ctx.accounts.clock)
        .emit(ctx.accounts.hpl_events.to_account_info())?;

    Ok(())
}

#[derive(Accounts)]
#[instruction(_env: String)]
pub struct AddWallet<'info> {
    /// The public info account
    #[account(
        seeds = [b"public_info".as_ref(), _env.as_bytes(), crate::id().as_ref()],
        bump = public_info.bump,
      )]
    pub public_info: Account<'info, PublicInfo>,

    /// The wallet resolver for the new wallet
    #[account(
        init, payer = new_wallet,
        space = WalletResolver::LEN,
        seeds = [b"wallet_resolver".as_ref(), new_wallet.key().as_ref()],
        bump
    )]
    pub wallet_resolver: Account<'info, WalletResolver>,

    /// The user accout
    #[account(mut)]
    pub user: Account<'info, User>,

    /// The new wallet being added to the user account
    #[account(mut)]
    pub new_wallet: Signer<'info>,

    /// One of the user's wallets or driver
    #[account(mut)]
    pub authority: Signer<'info>,

    /// System Program
    pub system_program: Program<'info, System>,

    /// NO OP program
    pub hpl_events: Program<'info, HplEvents>,

    /// NATIVE SYSVAR CLOCK
    pub clock: Sysvar<'info, Clock>,

    /// SYSVAR RENT
    pub rent_sysvar: Sysvar<'info, Rent>,

    /// NATIVE INSTRUCTIONS SYSVAR
    /// CHECK: This is not dangerous because we don't read or write from this account
    #[account(address = anchor_lang::solana_program::sysvar::instructions::ID)]
    pub instructions_sysvar: AccountInfo<'info>,
}

pub fn add_wallet(ctx: Context<AddWallet>, _env: String) -> Result<()> {
    let user = &mut ctx.accounts.user;

    reallocate(
        32 as isize,
        user.to_account_info(),
        ctx.accounts.new_wallet.to_account_info(),
        &ctx.accounts.rent_sysvar,
        &ctx.accounts.system_program,
    )?;

    user.secondary_wallets.push(ctx.accounts.new_wallet.key());

    let wallet_resolver = &mut ctx.accounts.wallet_resolver;
    wallet_resolver.set_defaults();
    wallet_resolver.bump = ctx.bumps["wallet_resolver"];
    wallet_resolver.user = user.key();
    wallet_resolver.wallet = ctx.accounts.new_wallet.key();

    // let user_seeds = [b"user".as_ref(), user.username.as_bytes(), &[user.bump]];
    // let user_signer = &[&user_seeds[..]];

    // add_verification_method(
    //     CpiContext::new_with_signer(
    //         ctx.accounts.sol_did_program.to_account_info(),
    //         AddVerificationMethod {
    //             did_data: ctx.accounts.did_data.to_account_info(),
    //             authority: user.to_account_info(),
    //         },
    //         user_signer,
    //     ),
    //     VerificationMethod {
    //         fragment: ctx.accounts.new_wallet.key().to_string(),
    //         flags: 0,
    //         method_type: 0,
    //         key_data: ctx.accounts.new_wallet.key().as_ref().to_vec(),
    //     },
    //     None,
    // )?;

    Event::update_user(user.key(), user.try_to_vec().unwrap(), &ctx.accounts.clock)
        .emit(ctx.accounts.hpl_events.to_account_info())?;

    Ok(())
}

#[derive(Accounts)]
#[instruction(_env: String)]
pub struct DeleteWallet<'info> {
    /// The public info account
    #[account(
        seeds = [b"public_info".as_ref(), _env.as_bytes(), crate::id().as_ref()],
        bump = public_info.bump,
      )]
    pub public_info: Account<'info, PublicInfo>,

    /// The wallet resolver of the wallet being removed
    #[account( mut, has_one = user, has_one = wallet, close = wallet )]
    pub wallet_resolver: Account<'info, WalletResolver>,

    /// The user account
    #[account(mut)]
    pub user: Account<'info, User>,

    /// The wallet being removed
    /// CHECK: This is not dangerous
    #[account(mut)]
    pub wallet: AccountInfo<'info>,

    /// One of the user's wallets or driver
    #[account(mut)]
    pub authority: Signer<'info>,

    /// System Program
    pub system_program: Program<'info, System>,

    /// NO OP program
    pub hpl_events: Program<'info, HplEvents>,

    /// NATIVE SYSVAR CLOCK
    pub clock: Sysvar<'info, Clock>,

    /// SYSVAR RENT
    pub rent_sysvar: Sysvar<'info, Rent>,

    /// NATIVE INSTRUCTIONS SYSVAR
    /// CHECK: This is not dangerous because we don't read or write from this account
    #[account(address = anchor_lang::solana_program::sysvar::instructions::ID)]
    pub instructions_sysvar: AccountInfo<'info>,
}

pub fn delete_wallet(ctx: Context<DeleteWallet>, _env: String) -> Result<()> {
    let user = &mut ctx.accounts.user;

    // remove wallet from secondary_wallets
    let index = user
        .secondary_wallets
        .clone()
        .into_iter()
        .position(|x| x == ctx.accounts.wallet.key());
    if let Some(i) = index {
        user.secondary_wallets.swap_remove(i);
    }

    reallocate(
        -32 as isize,
        user.to_account_info(),
        ctx.accounts.wallet.to_account_info(),
        &ctx.accounts.rent_sysvar,
        &ctx.accounts.system_program,
    )?;

    // let user_seeds = [b"user".as_ref(), user.username.as_bytes(), &[user.bump]];
    // let user_signer = &[&user_seeds[..]];

    // remove_verification_method(
    //     CpiContext::new_with_signer(
    //         ctx.accounts.sol_did_program.to_account_info(),
    //         RemoveVerificationMethod {
    //             did_data: ctx.accounts.did_data.to_account_info(),
    //             authority: user.to_account_info(),
    //         },
    //         user_signer,
    //     ),
    //     ctx.accounts.wallet.key().to_string(),
    //     None,
    // )?;

    Event::update_user(user.key(), user.try_to_vec().unwrap(), &ctx.accounts.clock)
        .emit(ctx.accounts.hpl_events.to_account_info())?;

    Ok(())
}

#[derive(Accounts)]
pub struct CloseOrphanWalletResolver<'info> {
    /// CHECK: This is not dangerous
    pub user: AccountInfo<'info>,

    /// The wallet resolver of the primary wallet
    #[account(mut, has_one = user, has_one = wallet, close = wallet)]
    pub wallet_resolver: Account<'info, WalletResolver>,

    /// The primary wallet
    /// CHECK: This is not dangerous
    #[account(mut)]
    pub wallet: AccountInfo<'info>,

    /// System Program
    pub system_program: Program<'info, System>,
}
pub fn close_orphan_wallet_resolver(ctx: Context<CloseOrphanWalletResolver>) -> Result<()> {
    if ctx.accounts.user.lamports() > 0 {
        panic!("User account still has lamports");
    }
    Ok(())
}