use solana_program::{
    account_info::AccountInfo,
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    pubkey::Pubkey,
};

entrypoint!(process_instruction);

fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    msg!("Hello, World! program_id: {:?}, accounts: {:?}, _instruction_data: {:?}.", program_id, accounts, _instruction_data);
    Ok(())
}

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
  account_info::{next_account_info, AccountInfo},
  entrypoint,
  entrypoint::ProgramResult,
  msg,
  program_error::ProgramError,
  pubkey::Pubkey,
  system_instruction,
  sysvar::rent::Rent,
  program::invoke_signed,
  borsh1::try_from_slice_unchecked,
};

#[derive(BorshSerialize, BorshDeserialize, Debug) ]
pub struct TokenMint {
  pub is_initialized: bool,
  pub total_supply: u64,
  pub mint_authority: Pubkey,
}

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct TokenAccount {
  pub is_initialized: bool,
  pub owner: Pubkey,
  pub balance: u64,
}

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub enum TokenInstruction {
  InitializeMint,
  Mint { amount: u64 },
  Transfer { amount: u64 },
  Balance,
}

entrypoint!(process_instruction);

pub fn process_instruction(
  program_id: &Pubkey,
  accounts: &[AccountInfo],
  instruction_data: &[u8],
) -> ProgramResult {
  let instruction = TokenInstruction::try_from_slice(instruction_data)
      .map_err(|_| ProgramError::InvalidInstructionData)?;

  match instruction {
    TokenInstruction::InitializeMint => {
      initialize_mint(program_id, accounts)
    },
    TokenInstruction::Mint { amount } => {
      mint_tokens(program_id, accounts, amount)
    },
    TokenInstruction::Transfer { amount } => {
      transfer_tokens(program_id, accounts, amount)
    },
    TokenInstruction::Balance => {
      get_balance(program_id, accounts)
    }
  }
}

fn initialize_mint(
  program_id: &Pubkey,
  accounts: &[AccountInfo],
) -> ProgramResult {
  let accounts_iter = &mut accounts.iter();
  let mint_account = next_account_info(accounts_iter)?;
  let authority_account = next_account_info(accounts_iter)?;
  let deployer_account = "2FAqSMicn8Wuxe3beYNdqk6ApKrXuhCGyHndQaqCdhzT";

  // authority_account should equal the deployer_account of the program.
  // Just like the OnerOnly modifier in Solidity.
  // But there's no convenient way to get the deployer account directly in Solana program so we have to hardcode it.
  if authority_account.key.to_string() != deployer_account {
    return Err(ProgramError::InvalidAccountData);
  }
  if authority_account.is_signer == false {
    return Err(ProgramError::MissingRequiredSignature);
  }
  if mint_account.data_is_empty() == false {
    return Err(ProgramError::AccountAlreadyInitialized);
  }
  // Solana force to provide every account in the instruction data(accounts array)
  // The invoker of initialize_mint must get the mint account address by calling the find_program_address method with same seeds
  let (mint_account_addr, bump_seed) = Pubkey::find_program_address(&[b"mint"], program_id);
  
  if mint_account_addr != *mint_account.key {
    return Err(ProgramError::InvalidAccountData);
  }
  
  // Create the mint account
  let space = std::mem::size_of::<TokenMint>();
  let lamports = Rent::default().minimum_balance(space);
  invoke_signed(
      &system_instruction::create_account(
        authority_account.key,
          mint_account.key,
          lamports,
          space as u64,
          program_id,
      ),
      &[authority_account.clone(), mint_account.clone()],
      &[&[&b"mint"[..], &[bump_seed]]],
  )?;

  // Initialize the mint account data
  let mint_account_data = TokenMint {
      is_initialized: true,
      total_supply : 0,
      mint_authority: *authority_account.key,
  };
  // Serialize and save the mint data to mint account
  mint_account_data.serialize(&mut &mut mint_account.data.borrow_mut()[..])?;

  msg!("Mint account created and initialized successfully. size: {}, data: {:?}", space, mint_account.data);
  Ok(())
}

fn mint_tokens(
  program_id: &Pubkey,
  accounts: &[AccountInfo],
  amount: u64,
) -> ProgramResult {
  let accounts_iter = &mut accounts.iter();
  let mint_account = next_account_info(accounts_iter)?;
  let destination_wallet_account = next_account_info(accounts_iter)?;
  let destination_token_account = next_account_info(accounts_iter)?;
  let authority_account = next_account_info(accounts_iter)?;
  // Only the mint_authority can mint tokens
  if authority_account.is_signer == false {
    return Err(ProgramError::MissingRequiredSignature);
  }
  if mint_account.data_is_empty() {
    return Err(ProgramError::UninitializedAccount);
  }
  let mut mint_data: TokenMint = try_from_slice_unchecked::<TokenMint>(&mint_account.data.borrow())?;
  if mint_data.mint_authority != *authority_account.key {
    return Err(ProgramError::MissingRequiredSignature);
  }
  // If the destination_token_account is not initialized, create and initialize it
  if destination_token_account.data_is_empty() {
    let (token_account_addr, bump_seed) = Pubkey::find_program_address(
      &[mint_account.key.as_ref(), destination_wallet_account.key.as_ref()],
      program_id,
    );
    if token_account_addr != *destination_token_account.key {
      return Err(ProgramError::InvalidAccountData);
    }
    let space = std::mem::size_of::<TokenAccount>();
    let lamports = Rent::default().minimum_balance(space);
    invoke_signed(
      &system_instruction::create_account(
        authority_account.key,
        destination_token_account.key,
        lamports,
        space as u64,
        program_id,
      ),
      &[authority_account.clone(), destination_token_account.clone()],
      &[&[&mint_account.key.to_bytes(), &destination_wallet_account.key.to_bytes(), &[bump_seed]]],
    )?;
    let token_account_data = TokenAccount {
      is_initialized: true,
      owner: *destination_wallet_account.key,
      balance: 0,
    };
    token_account_data.serialize(&mut &mut destination_token_account.data.borrow_mut()[..])?;
  }
  let mut token_account_data = try_from_slice_unchecked::<TokenAccount>(&destination_token_account.data.borrow())?;
  token_account_data.balance += amount;
  mint_data.total_supply += amount;
  token_account_data.serialize(&mut &mut destination_token_account.data.borrow_mut()[..])?;
  mint_data.serialize(&mut &mut mint_account.data.borrow_mut()[..])?;
  msg!("Tokens minted successfully.");
  Ok(())
}

fn transfer_tokens(
  program_id: &Pubkey,
  accounts: &[AccountInfo],
  amount: u64,
) -> ProgramResult {
  let accounts_iter = &mut accounts.iter();
  let mint_account = next_account_info(accounts_iter)?;
  let source_wallet_account = next_account_info(accounts_iter)?;
  let source_token_account = next_account_info(accounts_iter)?;
  let destination_wallet_account = next_account_info(accounts_iter)?;
  let destination_token_account = next_account_info(accounts_iter)?;

  if source_wallet_account.is_signer == false {
    return Err(ProgramError::MissingRequiredSignature);
  }
  if mint_account.data_is_empty() {
    return Err(ProgramError::UninitializedAccount);
  }
  if source_token_account.data_is_empty() {
    return Err(ProgramError::InvalidAccountData);
  }
  let mut source_data = try_from_slice_unchecked::<TokenAccount>(&source_token_account.data.borrow())?;
  if source_data.balance < amount {
    return Err(ProgramError::InsufficientFunds);
  }

  // If the destination_token_account is not initialized, create and initialize it
  if destination_token_account.data_is_empty() {
    let (destination_token_account_addr, bump_seed) = Pubkey::find_program_address(
      &[mint_account.key.as_ref(), destination_wallet_account.key.as_ref()],
      program_id,
    );
    if destination_token_account_addr != *destination_token_account.key {
      return Err(ProgramError::InvalidAccountData);
    }
    let space = std::mem::size_of::<TokenAccount>();
    let lamports = Rent::default().minimum_balance(space);
    invoke_signed(
      &system_instruction::create_account(
        source_wallet_account.key,
        destination_token_account.key,
        lamports,
        space as u64,
        program_id,
      ),
      &[source_wallet_account.clone(), destination_token_account.clone()],
      &[&[&mint_account.key.to_bytes(), &destination_wallet_account.key.to_bytes(), &[bump_seed]]],
    )?;
    let destination_data = TokenAccount {
      is_initialized: true,
      owner: *destination_wallet_account.key,
      balance: 0,
    };
    destination_data.serialize(&mut &mut destination_token_account.data.borrow_mut()[..])?;
  }

  let mut destination_data = try_from_slice_unchecked::<TokenAccount>(&destination_token_account.data.borrow())?;
  source_data.balance -= amount;
  destination_data.balance += amount;

  source_data.serialize(&mut &mut source_token_account.data.borrow_mut()[..])?;
  destination_data.serialize(&mut &mut destination_token_account.data.borrow_mut()[..])?;

  msg!("Tokens transferred successfully.");
  Ok(())
}

fn get_balance(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
  let accounts_iter = &mut accounts.iter();
  let token_account = next_account_info(accounts_iter)?;

  // If the token_account is not initialized, that means user never holds this token
  if token_account.data_is_empty() {
    msg!("Balance: 0");
    return Ok(());
  }
  let account_data = try_from_slice_unchecked::<TokenAccount>(&token_account.data.borrow())?;
  msg!("Balance: {}", account_data.balance);

  Ok(())
}

// 1. Import dependencies
use anchor_lang::prelude::*;
use anchor_spl::{
    associated_token::AssociatedToken,
    token::{mint_to, Mint, MintTo, Token, TokenAccount},
    metadata::{
        create_metadata_accounts_v3,
        mpl_token_metadata::types::DataV2,
        CreateMetadataAccountsV3, 
        Metadata as Metaplex,
    },
};

// 2. Declare Program ID (SolPG will automatically update this when you deploy)
declare_id!("3sa7pXhNJLRTrMkwRAF8i4QupD4aKGXfRwQNTNBaw9sr");

// 3. Define the program and instructions
#[program]
mod token_minter {
    use super::*;
    pub fn init_token(ctx: Context<InitToken>, metadata: InitTokenParams) -> Result<()> {
      let seeds = &["mint".as_bytes(), &[ctx.bumps.mint]];
      let signer = [&seeds[..]];

      let token_data: DataV2 = DataV2 {
        name: metadata.name,
        symbol: metadata.symbol,
        uri: metadata.uri,
        seller_fee_basis_points: 0,
        creators: None,
        collection: None,
        uses: None,
      };

      let metadata_ctx = CpiContext::new_with_signer(
        ctx.accounts.token_metadata_program.to_account_info(),
        CreateMetadataAccountsV3 {
          payer: ctx.accounts.payer.to_account_info(),
          update_authority: ctx.accounts.mint.to_account_info(),
          mint: ctx.accounts.mint.to_account_info(),
          metadata: ctx.accounts.metadata.to_account_info(),
          mint_authority: ctx.accounts.mint.to_account_info(),
          system_program: ctx.accounts.system_program.to_account_info(),
          rent: ctx.accounts.rent.to_account_info(),
        },
        &signer
      );

      create_metadata_accounts_v3(
        metadata_ctx,
        token_data,
        false,
        true,
        None,
      )?;

      msg!("Token mint created successfully.");
      Ok(())
    }

    pub fn mint_tokens(ctx: Context<MintTokens>, quantity: u64) -> Result<()> {
      let seeds = &["mint".as_bytes(), &[ctx.bumps.mint]];
      let signer = [&seeds[..]];

      mint_to(
        CpiContext::new_with_signer(
          ctx.accounts.token_program.to_account_info(),
          MintTo {
            authority: ctx.accounts.mint.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            mint: ctx.accounts.mint.to_account_info(),
          },
          &signer,
        ),
        quantity,
      )?;
      Ok(())
    }
}

// 4. Define the context for each instruction
#[derive(Accounts)]
#[instruction(params: InitTokenParams)]
pub struct InitToken<'info> {
  /// CHECK: New Metaplex Account being created
  #[account(mut)]
  pub metadata: UncheckedAccount<'info>,

  #[account(
      init,
      seeds = [b"mint"],
      bump,
      payer = payer,
      mint::decimals = params.decimals,
      mint::authority = mint,
  )]
  pub mint: Account<'info, Mint>,

  #[account(mut)]
  pub payer: Signer<'info>,
  pub rent: Sysvar<'info, Rent>,
  pub system_program: Program<'info, System>,
  pub token_program: Program<'info, Token>,
  pub token_metadata_program: Program<'info, Metaplex>,
}

#[derive(Accounts)]
pub struct MintTokens<'info> {
  #[account(
    mut,
    seeds = [b"mint"],
    bump,
    mint::authority = mint,
  )]
  pub mint: Account<'info, Mint>,

  #[account(
    init_if_needed,
    payer = payer,
    associated_token::mint = mint,
    associated_token::authority = receiver,
  )]
  pub destination: Account<'info, TokenAccount>,

  /// CHECK: The receiver of minted tokens don't need to sign the mint instruction, so wa can airdrop tokens to any account
  pub receiver: UncheckedAccount<'info>, 

  #[account(mut)]
  pub payer: Signer<'info>,
  pub rent: Sysvar<'info, Rent>,
  pub system_program: Program<'info, System>,
  pub token_program: Program<'info, Token>,
  pub associated_token_program: Program<'info, AssociatedToken>,
}

// 5. Define the init token params
#[derive(AnchorSerialize, AnchorDeserialize, Debug, Clone)]
pub struct InitTokenParams {
    pub name: String,
    pub symbol: String,
    pub uri: String,
    pub decimals: u8,
}