use {
    crate::{
        assertions::{assert_merkle_tree, assert_user},
        errors::ErrorCode,
        state::*,
    },
    anchor_lang::prelude::*,
    hpl_utils::{reallocate, traits::Default},
    // sol_did::{
    //     cpi::{
    //         accounts::{AddService, RemoveService},
    //         add_service, remove_service,
    //     },
    //     program::SolDid,
    //     state::{DidAccount, Service},
    // },
    spl_account_compression::{
        cpi::{
            accounts::{CloseTree, Initialize, Modify, VerifyLeaf},
            append, close_empty_tree, init_empty_merkle_tree, replace_leaf, verify_leaf,
        },
        program::SplAccountCompression,
        Node, Noop,
    },
};

#[derive(Accounts)]
#[instruction(args: CreateProfileArgs)]
pub struct CreateProfile<'info> {
    /// The user state account
    #[account()]
    pub user: Box<Account<'info, User>>,

    /// The project state account
    #[account()]
    pub project: Box<Account<'info, Project>>,

    /// User's profile for the provided project
    #[account(
        init, payer = wallet,
        space = Profile::LEN,
        seeds = [
            b"profile".as_ref(),
            project.key().as_ref(),
            user.key().as_ref(),
            &args.identity.to_bytes()[..]
        ],
        bump
      )]
    pub profile: Account<'info, Profile>,

    /// User's decentralized identity data account
    /// CHECK: This is not dangerous, not deserializing becase of version mismatch
    #[account(mut)]
    pub did_data: AccountInfo<'info>,

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

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

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

    /// SOL DID Program
    /// CHECK: This is not dangerous, not deserializing becase of version mismatch
    pub sol_did_program: AccountInfo<'info>,

    /// NO OP program
    pub log_wrapper: Program<'info, Noop>,

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

    /// The vault that collects the fees.
    /// CHECK: This is not dangerous
    #[account(mut)]
    pub vault: AccountInfo<'info>,
}

/// Structure representing the arguments for creating a new profile on the chain.
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, PartialEq)]
pub struct CreateProfileArgs {
    /// Identity of the profile being created. It can be one of the following variants:
    /// - `ProfileIdentity::Main`: Represents the main identity of the profile.
    /// - `ProfileIdentity::Wallet`: Represents an identity associated with a specific wallet.
    /// - `ProfileIdentity::Value`: Represents an identity with a custom string value.
    pub identity: ProfileIdentity,
}

pub fn create_profile(ctx: Context<CreateProfile>, args: CreateProfileArgs) -> Result<()> {
    assert_user(&ctx.accounts.user, ctx.accounts.wallet.key())?;

    let profile = &mut ctx.accounts.profile;
    profile.set_defaults();
    profile.bump = ctx.bumps["profile"];
    profile.project = ctx.accounts.project.key();
    profile.user = ctx.accounts.user.key();
    profile.identity = args.identity.clone();

    // let did_data = DidAccount::try_from(&ctx.accounts.did_data, &ctx.accounts.user.key(), None)?;
    // msg!("Services: {}", did_data.services.len());
    // if did_data.services.len() < 5 {
    //     let user_seeds = [
    //         b"user".as_ref(),
    //         ctx.accounts.user.username.as_bytes(),
    //         &[ctx.accounts.user.bump],
    //     ];
    //     let user_signer = &[&user_seeds[..]];
    //     // TODO: DID account size limitation; create issue and open PR
    //     add_service(
    //         CpiContext::new_with_signer(
    //             ctx.accounts.sol_did_program.to_account_info(),
    //             AddService {
    //                 did_data: ctx.accounts.did_data.to_account_info(),
    //                 authority: ctx.accounts.user.to_account_info(),
    //             },
    //             user_signer,
    //         ),
    //         Service {
    //             fragment: format!(
    //                 "{};{}",
    //                 ctx.accounts.project.key().to_string(),
    //                 args.identity.to_string()
    //             ),
    //             service_type: "HoneycombProject".to_string(),
    //             service_endpoint: "https://did-resolver.honeycombprotocol.com".to_string(),
    //         },
    //         false,
    //         None,
    //     )?;
    // }

    Event::new_profile(profile.key(), &profile, &ctx.accounts.clock)
        .wrap(ctx.accounts.log_wrapper.to_account_info())?;

    Ok(())
}

#[derive(Accounts)]
pub struct DeleteProfile<'info> {
    /// The user state account
    #[account()]
    pub user: Box<Account<'info, User>>,

    /// The project state account
    #[account()]
    pub project: Box<Account<'info, Project>>,

    /// User's profile for the provided project
    #[account(mut, has_one = user, has_one = project, close = wallet)]
    pub profile: Account<'info, Profile>,

    /// User's decentralized identity data account
    /// CHECK: This is not dangerous, not deserializing becase of version mismatch
    #[account(mut)]
    pub did_data: AccountInfo<'info>,

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

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

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

    /// SOL DID Program
    /// CHECK: This is not dangerous, not deserializing becase of version mismatch
    pub sol_did_program: AccountInfo<'info>,

    /// NO OP program
    pub log_wrapper: Program<'info, Noop>,

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

    /// The vault that collects the fees.
    /// CHECK: This is not dangerous
    #[account(mut)]
    pub vault: AccountInfo<'info>,
}

pub fn delete_profile(ctx: Context<DeleteProfile>) -> Result<()> {
    assert_user(&ctx.accounts.user, ctx.accounts.wallet.key())?;

    // let fragment = format!(
    //     "{};{}",
    //     ctx.accounts.project.key().to_string(),
    //     ctx.accounts.profile.identity.to_string()
    // );
    // let found = ctx
    //     .accounts
    //     .did_data
    //     .services
    //     .iter()
    //     .find(|s| s.fragment == fragment);

    // if found.is_some() {
    //     let user_seeds = [
    //         b"user".as_ref(),
    //         ctx.accounts.user.username.as_bytes(),
    //         &[ctx.accounts.user.bump],
    //     ];
    //     let user_signer = &[&user_seeds[..]];

    //     remove_service(
    //         CpiContext::new_with_signer(
    //             ctx.accounts.sol_did_program.to_account_info(),
    //             RemoveService {
    //                 did_data: ctx.accounts.did_data.to_account_info(),
    //                 authority: ctx.accounts.user.to_account_info(),
    //             },
    //             user_signer,
    //         ),
    //         fragment,
    //         None,
    //     )?;
    // }

    Ok(())
}

#[derive(Accounts)]
pub struct ManageProfileData<'info> {
    /// The project state account
    #[account()]
    pub project: Box<Account<'info, Project>>,

    /// User's profile for the provided project
    #[account(mut, has_one = project)]
    pub profile: Box<Account<'info, Profile>>,

    /// [Option] The merkle tree account
    /// CHECK: This account must have same authority as profile
    #[account(mut)]
    pub merkle_tree: Option<UncheckedAccount<'info>>,

    /// [Option] delegate authority account
    #[account()]
    pub delegate_authority: Option<Account<'info, DelegateAuthority>>,

    /// The authority (or delegate) of the project.
    pub authority: Signer<'info>,

    /// The wallet that pays for the rent.
    #[account(mut)]
    pub payer: Signer<'info>,

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

    /// NATIVE Instructions SYSVAR
    /// CHECK: This is not dangerous
    #[account(address = anchor_lang::solana_program::sysvar::instructions::ID)]
    pub instructions_sysvar: AccountInfo<'info>,

    /// The system program.
    pub system_program: Program<'info, System>,

    /// SPL Account Compression program
    pub compression_program: Program<'info, SplAccountCompression>,

    /// NO OP program
    pub log_wrapper: Program<'info, Noop>,

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

    /// The vault that collects the fees.
    /// CHECK: This is not dangerous
    #[account(mut)]
    pub vault: AccountInfo<'info>,
}
/// Structure representing the arguments for adding profile data to a profile.
///
/// # Fields
///
/// - `label`: Label or name of the profile data being added.
/// - `value`: Value of the profile data being added. It can be one of the following variants:
///     - `None`: If no value is provided.
///     - `Some(AddProfileDataArgsValue::SingleValue)`: Represents a single string value.
///     - `Some(AddProfileDataArgsValue::MultiValue)`: Represents a list of string values.
///     - `Some(AddProfileDataArgsValue::EntityData)`: Represents an entity data node (32-byte array).
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct AddProfileDataArgs {
    pub label: String,
    pub value: Option<AddProfileDataArgsValue>,
}

/// Enum representing different types of profile data values that can be added to a profile.
///
/// # Variants
///
/// - `SingleValue`: Represents a single string value.
///     - `value`: The single string value to be added to the profile.
///
/// - `MultiValue`: Represents a list of string values.
///     - `value`: The list of string values to be added to the profile.
///
/// - `EntityData`: Represents an merkle tree node (32-byte array).
///     - `node`: The 32-byte array representing the entity data node to be added to the cocurret merkle tree.
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub enum AddProfileDataArgsValue {
    SingleValue { value: String },
    MultiValue { value: Vec<String> },
    EntityData { node: [u8; 32] },
}

pub fn add_profile_data(ctx: Context<ManageProfileData>, args: AddProfileDataArgs) -> Result<()> {
    assert_eq!(
        ctx.accounts
            .project
            .profile_data_config
            .contains_key(&args.label),
        true
    );

    let profile = &mut ctx.accounts.profile;

    if args.value.is_none()
        || !matches!(
            args.value.clone().unwrap(),
            AddProfileDataArgsValue::EntityData { node: _ }
        )
    {
        reallocate(
            40 + 24 as isize,
            profile.to_account_info(),
            ctx.accounts.payer.to_account_info(),
            &ctx.accounts.rent_sysvar,
            &ctx.accounts.system_program,
        )?
    }

    let config = ctx
        .accounts
        .project
        .profile_data_config
        .get(&args.label)
        .unwrap();

    match config {
        ProfileDataType::SingleValue => {
            if args.value.is_none() {
                return Err(ErrorCode::InvalidValueType.into());
            }

            if profile.data.get(&args.label).is_some() {
                match profile.data.get(&args.label).unwrap() {
                    ProfileData::SingleValue { value } => {
                        if value != "" {
                            return Err(ErrorCode::NonEmptyDataAdd.into());
                        }
                    }
                    _ => return Err(ErrorCode::InvalidValueType.into()),
                }
            }

            if let AddProfileDataArgsValue::SingleValue { value } = args.value.unwrap() {
                profile
                    .data
                    .insert(args.label, ProfileData::SingleValue { value });
                return Ok(());
            } else {
                return Err(ErrorCode::InvalidValueType.into());
            }
        }
        ProfileDataType::MultiValue => {
            if args.value.is_none() {
                return Err(ErrorCode::InvalidValueType.into());
            }

            if profile.data.get(&args.label).is_some() {
                match profile.data.get(&args.label).unwrap() {
                    ProfileData::MultiValue { value } => {
                        if value.len() > 0 {
                            return Err(ErrorCode::NonEmptyDataAdd.into());
                        }
                    }
                    _ => return Err(ErrorCode::InvalidValueType.into()),
                }
            }

            if let AddProfileDataArgsValue::MultiValue { value } = args.value.unwrap() {
                profile
                    .data
                    .insert(args.label, ProfileData::MultiValue { value });
                return Ok(());
            } else {
                return Err(ErrorCode::InvalidValueType.into());
            }
        }
        ProfileDataType::Entity {
            merkle_tree_max_depth,
            merkle_tree_max_buffer_size,
        } => {
            let project_seeds = [
                b"project".as_ref(),
                ctx.accounts.project.key.as_ref(),
                &[ctx.accounts.project.bump],
            ];
            let project_signer = &[&project_seeds[..]];

            let merkle_tree = ctx
                .accounts
                .merkle_tree
                .as_ref()
                .ok_or(ErrorCode::MissingMerkleTree)?;

            if args.value.is_none() {
                init_empty_merkle_tree(
                    CpiContext::new_with_signer(
                        ctx.accounts.compression_program.to_account_info(),
                        Initialize {
                            merkle_tree: merkle_tree.to_account_info(),
                            authority: ctx.accounts.project.to_account_info(),
                            noop: ctx.accounts.log_wrapper.to_account_info(),
                        },
                        project_signer,
                    ),
                    *merkle_tree_max_depth,
                    *merkle_tree_max_buffer_size,
                )?;

                profile.data.insert(
                    args.label,
                    ProfileData::Entity {
                        tree: merkle_tree.key(),
                    },
                );
            } else {
                if let AddProfileDataArgsValue::EntityData { node } = args.value.unwrap() {
                    assert_merkle_tree(&ctx.accounts.profile, merkle_tree.key())?;
                    return append(
                        CpiContext::new_with_signer(
                            ctx.accounts.compression_program.to_account_info(),
                            Modify {
                                merkle_tree: merkle_tree.to_account_info(),
                                authority: ctx.accounts.project.to_account_info(),
                                noop: ctx.accounts.log_wrapper.to_account_info(),
                            },
                            project_signer,
                        ),
                        node,
                    );
                } else {
                    return Err(ErrorCode::InvalidValueType.into());
                }
            }
        }
    }

    Event::update_profile(profile.key(), &profile, &ctx.accounts.clock)
        .wrap(ctx.accounts.log_wrapper.to_account_info())?;

    Ok(())
}

/// Structure representing the arguments for modifying profile data in a profile.
///
/// # Fields
///
/// - `label`: Label or name of the profile data being modified.
/// - `value`: Value of the profile data being modified. It can be one of the following variants:
///     - `ModifyProfileDataArgsValue::SingleValue`: Represents a single string value.
///         - `value`: The updated single string value for the profile data.
///     - `ModifyProfileDataArgsValue::MultiValue`: Represents a list of string values.
///         - `value`: The updated list of string values for the profile data.
///     - `ModifyProfileDataArgsValue::EntityData`: Represents an updated entity data node (32-byte array) in a Merkle tree.
///         - `root`: The 32-byte array representing the Merkle root hash.
///         - `leaf`: The original 32-byte array representing the Merkle leaf hash to be updated.
///         - `updated_leaf`: The updated 32-byte array representing the new Merkle leaf hash.
///         - `leaf_index`: The index of the leaf node to be updated in the Merkle tree.
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct ModifyProfileDataArgs {
    pub label: String,
    pub value: ModifyProfileDataArgsValue,
}

/// Enum representing different types of profile data values that can be modified in a profile.
///
/// # Variants
///
/// - `SingleValue`: Represents a single string value.
///     - `value`: The updated single string value for the profile data.
///
/// - `MultiValue`: Represents a list of string values.
///     - `value`: The updated list of string values for the profile data.
///
/// - `EntityData`: Represents an updated entity data node (32-byte array) in a Merkle tree.
///     - `root`: The 32-byte array representing the Merkle root hash.
///     - `leaf`: The original 32-byte array representing the Merkle leaf hash to be updated.
///     - `updated_leaf`: The updated 32-byte array representing the new Merkle leaf hash.
///     - `leaf_index`: The index of the leaf node to be updated in the Merkle tree.
#[derive(AnchorSerialize, AnchorDeserialize)]
pub enum ModifyProfileDataArgsValue {
    SingleValue {
        value: String,
    },
    MultiValue {
        value: Vec<String>,
    },
    EntityData {
        root: [u8; 32],
        leaf: [u8; 32],
        updated_leaf: [u8; 32],
        leaf_index: u32,
    },
}

pub fn modify_profile_data(
    ctx: Context<ManageProfileData>,
    args: ModifyProfileDataArgs,
) -> Result<()> {
    let profile = &mut ctx.accounts.profile;
    let res = match &profile.data[&args.label] {
        ProfileData::SingleValue { value: _ } => {
            if let ModifyProfileDataArgsValue::SingleValue { value } = args.value {
                profile
                    .data
                    .insert(args.label, ProfileData::SingleValue { value });
                Ok(())
            } else {
                Err(ErrorCode::InvalidValueType.into())
            }
        }
        ProfileData::MultiValue { value: _ } => {
            if let ModifyProfileDataArgsValue::MultiValue { value } = args.value {
                profile
                    .data
                    .insert(args.label, ProfileData::MultiValue { value });
                Ok(())
            } else {
                Err(ErrorCode::InvalidValueType.into())
            }
        }
        ProfileData::Entity { tree: _ } => {
            if let ModifyProfileDataArgsValue::EntityData {
                root,
                leaf,
                updated_leaf,
                leaf_index,
            } = args.value
            {
                let merkle_tree = ctx
                    .accounts
                    .merkle_tree
                    .as_ref()
                    .ok_or(ErrorCode::MissingMerkleTree)?;
                assert_merkle_tree(&profile, merkle_tree.key())?;

                let project_seeds = [
                    b"project".as_ref(),
                    ctx.accounts.project.key.as_ref(),
                    &[ctx.accounts.project.bump],
                ];
                let project_signer = &[&project_seeds[..]];

                replace_leaf(
                    CpiContext::new_with_signer(
                        ctx.accounts.compression_program.to_account_info(),
                        Modify {
                            merkle_tree: merkle_tree.to_account_info(),
                            authority: ctx.accounts.project.to_account_info(),
                            noop: ctx.accounts.log_wrapper.to_account_info(),
                        },
                        project_signer,
                    ),
                    root,
                    leaf,
                    updated_leaf,
                    leaf_index,
                )
            } else {
                Err(ErrorCode::InvalidValueType.into())
            }
        }
    };

    Event::update_profile(profile.key(), &profile, &ctx.accounts.clock)
        .wrap(ctx.accounts.log_wrapper.to_account_info())?;

    res
}

/// Structure representing the arguments for removing profile data from a profile.
///
/// # Fields
///
/// - `label`: Label or name of the profile data being removed.
/// - `value`: Value of the profile data being removed. It can be one of the following variants:
///     - `RemoveProfileDataArgsValue::SingleValue`: Represents a single string value to be removed.
///     - `RemoveProfileDataArgsValue::MultiValue`: Represents a list of string values to be removed.
///     - `RemoveProfileDataArgsValue::EntityData`: Represents an entity data node (32-byte array) in a Merkle tree to be removed.
///         - `root`: The 32-byte array representing the Merkle root hash.
///         - `leaf`: The 32-byte array representing the Merkle leaf hash to be removed.
///         - `leaf_index`: The index of the leaf node to be removed in the Merkle tree.
///     - `RemoveProfileDataArgsValue::Entity`: Represents a complete entity profile to be removed.
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct RemoveProfileDataArgs {
    pub label: String,
    pub value: RemoveProfileDataArgsValue,
}

/// Enum representing different types of profile data values that can be removed from a profile.
///
/// # Variants
///
/// - `SingleValue`: Represents a single string value to be removed.
///
/// - `MultiValue`: Represents a list of string values to be removed.
///
/// - `EntityData`: Represents an entity data node (32-byte array) in a Merkle tree to be removed.
///     - `root`: The 32-byte array representing the Merkle root hash.
///     - `leaf`: The 32-byte array representing the Merkle leaf hash to be removed.
///     - `leaf_index`: The index of the leaf node to be removed in the Merkle tree.
///
/// - `Entity`: Represents a complete entity profile to be removed.
#[derive(AnchorSerialize, AnchorDeserialize, PartialEq)]
pub enum RemoveProfileDataArgsValue {
    SingleValue,
    MultiValue,
    EntityData {
        root: [u8; 32],
        leaf: [u8; 32],
        leaf_index: u32,
    },
    Entity,
}

pub fn remove_profile_data(
    ctx: Context<ManageProfileData>,
    args: RemoveProfileDataArgs,
) -> Result<()> {
    let project_seeds = [
        b"project".as_ref(),
        ctx.accounts.project.key.as_ref(),
        &[ctx.accounts.project.bump],
    ];
    let project_signer = &[&project_seeds[..]];

    let res = match args.value {
        RemoveProfileDataArgsValue::EntityData {
            root,
            leaf,
            leaf_index,
        } => {
            let merkle_tree = ctx
                .accounts
                .merkle_tree
                .as_ref()
                .ok_or(ErrorCode::MissingMerkleTree)?;
            assert_merkle_tree(&ctx.accounts.profile, merkle_tree.key())?;

            replace_leaf(
                CpiContext::new_with_signer(
                    ctx.accounts.compression_program.to_account_info(),
                    Modify {
                        merkle_tree: merkle_tree.to_account_info(),
                        authority: ctx.accounts.project.to_account_info(),
                        noop: ctx.accounts.log_wrapper.to_account_info(),
                    },
                    project_signer,
                ),
                root,
                leaf,
                Node::default(),
                leaf_index,
            )
        }
        _ => {
            if args.value == RemoveProfileDataArgsValue::Entity {
                let merkle_tree = ctx
                    .accounts
                    .merkle_tree
                    .as_ref()
                    .ok_or(ErrorCode::MissingMerkleTree)?;
                assert_merkle_tree(&ctx.accounts.profile, merkle_tree.key())?;

                close_empty_tree(CpiContext::new_with_signer(
                    ctx.accounts.compression_program.to_account_info(),
                    CloseTree {
                        merkle_tree: merkle_tree.to_account_info(),
                        authority: ctx.accounts.project.to_account_info(),
                        recipient: ctx.accounts.payer.to_account_info(),
                    },
                    project_signer,
                ))?;
            }

            let profile = &mut ctx.accounts.profile;
            profile.data.remove(&args.label);

            reallocate(
                -40 - 24 as isize,
                profile.to_account_info(),
                ctx.accounts.payer.to_account_info(),
                &ctx.accounts.rent_sysvar,
                &ctx.accounts.system_program,
            )
        }
    };

    Event::update_profile(
        ctx.accounts.profile.key(),
        &ctx.accounts.profile,
        &ctx.accounts.clock,
    )
    .wrap(ctx.accounts.log_wrapper.to_account_info())?;

    res
}

/// Structure representing the arguments for verifying profile entity data in a profile.
///
/// # Fields
///
/// - `root`: The 32-byte array representing the Merkle root hash of the profile.
/// - `leaf`: The 32-byte array representing the Merkle leaf hash to be verified.
/// - `leaf_index`: The index of the leaf node to be verified in the Merkle tree.
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct VerifyProfileEntityDataArgs {
    root: [u8; 32],
    leaf: [u8; 32],
    leaf_index: u32,
}

pub fn verify_profile_entity_data(
    ctx: Context<ManageProfileData>,
    args: VerifyProfileEntityDataArgs,
) -> Result<()> {
    let merkle_tree = ctx
        .accounts
        .merkle_tree
        .as_ref()
        .ok_or(ErrorCode::MissingMerkleTree)?;
    assert_merkle_tree(&ctx.accounts.profile, merkle_tree.key())?;

    let project_seeds = [
        b"project".as_ref(),
        ctx.accounts.project.key.as_ref(),
        &[ctx.accounts.project.bump],
    ];
    let project_signer = &[&project_seeds[..]];

    verify_leaf(
        CpiContext::new_with_signer(
            ctx.accounts.compression_program.to_account_info(),
            VerifyLeaf {
                merkle_tree: merkle_tree.to_account_info(),
            },
            project_signer,
        ),
        args.root,
        args.leaf,
        args.leaf_index,
    )
}