from solders.keypair import Keypair
from solana.rpc.api import Client
from solana.transaction import Transaction
from solders.system_program import create_account, CreateAccountParams
from spl.token.instructions import (
    initialize_mint,
    InitializeMintParams,
    mint_to,
    MintToParams,
    initialize_account,
    InitializeAccountParams,
)
from solana.transaction import Transaction
from spl.token.constants import (
    TOKEN_PROGRAM_ID,
)


def token_to_decimals(amount: float | int) -> int:
    DECIMALS = 1000000000
    return int(amount * DECIMALS)


def create_spl_token():

    client = Client("https://api.devnet.solana.com")

    with open(
        "solana/keywbrUGnsKa9USpCsFwUZFENQ6jmrZHQfEz3Fw8wXJ.json"
    ) as file:
        keypair_json = file.read()

    payer: Keypair = Keypair.from_json(keypair_json)
    # Airdrop some SOL to the payer
    # client.request_airdrop(payer.pubkey(), 1000000000)  # 1 SOL

    # Generate a new keypair for the mint
    mint = Keypair()

    # Get the minimum lamports required for rent exemption
    mint_rent = client.get_minimum_balance_for_rent_exemption(82)

    # Create the mint account
    create_mint_params = CreateAccountParams(
        from_pubkey=payer.pubkey(),
        to_pubkey=mint.pubkey(),
        lamports=mint_rent.value,
        space=82,
        owner=TOKEN_PROGRAM_ID,
    )
    create_mint_account_ix = create_account(params=create_mint_params)

    # Initialize the mint
    init_mint_params = InitializeMintParams(
        program_id=TOKEN_PROGRAM_ID,
        mint=mint.pubkey(),
        decimals=9,
        mint_authority=payer.pubkey(),
        freeze_authority=payer.pubkey(),
    )
    init_mint_ix = initialize_mint(params=init_mint_params)

    # Create and send the transaction
    tx = Transaction().add(create_mint_account_ix, init_mint_ix)
    response = client.send_transaction(tx, payer, mint)

    print(f"Initialized mint account: {mint.pubkey()}")
    print(f"Transaction Signature: {response.value}")
    print("\n")

    # Create a token account for the payer
    token_account = Keypair()
    token_account_rent = client.get_minimum_balance_for_rent_exemption(165)

    create_account_params = CreateAccountParams(
        from_pubkey=payer.pubkey(),
        to_pubkey=token_account.pubkey(),
        lamports=token_account_rent.value,
        space=165,
        owner=TOKEN_PROGRAM_ID,
    )
    create_token_account_ix = create_account(params=create_account_params)

    init_account_params = InitializeAccountParams(
        program_id=TOKEN_PROGRAM_ID,
        account=token_account.pubkey(),
        mint=mint.pubkey(),
        owner=payer.pubkey(),
    )

    init_account_ix = initialize_account(params=init_account_params)

    tx = Transaction().add(create_token_account_ix, init_account_ix)
    response = client.send_transaction(tx, payer, token_account)

    print(f"Initialized token account: {token_account.pubkey()}")
    print(f"Transaction Signature: {response.value}")
    print("\n")

    mint_amount = 1000
    # Mint tokens to the account
    mint_to_ix = mint_to(
        MintToParams(
            program_id=TOKEN_PROGRAM_ID,
            mint=mint.pubkey(),
            dest=token_account.pubkey(),
            mint_authority=payer.pubkey(),
            amount=token_to_decimals(mint_amount),  # 1 token with 9 decimals
        )
    )

    # Create and send the transaction
    tx = Transaction().add(mint_to_ix)
    response = client.send_transaction(tx, payer)

    print(f"Token mint address: {mint.pubkey()}")
    print(f"Token account address: {token_account.pubkey()}")
    print(f"Minted {mint_amount} to {token_account.pubkey()}")
    print(f"Transaction Signature: {response.value}")
    print("\n")


if __name__ == "__main__":
    create_spl_token()