use borsh::{BorshDeserialize, BorshSerialize}; // Borsh 라이브러리를 가져와서 직렬화 및 역직렬화 기능을 사용합니다.
use solana_program::{
    account_info::{next_account_info, AccountInfo}, // 계정 정보를 가져오는 모듈
    clock::Clock, // 시스템 클락 정보를 가져오는 모듈
    entrypoint, // 프로그램의 진입점을 정의하는 모듈
    entrypoint::ProgramResult, // 프로그램의 결과를 정의하는 타입
    msg, // 로그 메시지를 출력하는 매크로
    program_error::ProgramError, // 프로그램 오류를 정의하는 모듈
    pubkey::Pubkey, // 공개 키 타입
    rent::Rent, // 임대료 관련 정보를 가져오는 모듈
    system_program::ID as SYSTEM_PROGRAM_ID, // 시스템 프로그램의 ID를 가져옴
    sysvar::Sysvar, // 시스템 변수 관련 모듈
};

// 프로그램의 진입점을 process_instruction 함수로 설정
entrypoint!(process_instruction);

// HelloState 구조체 정의: 프로그램의 상태를 나타냅니다.
#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct HelloState {
    is_initialized: bool, // 초기화 여부를 나타내는 필드
}

// process_instruction 함수: 프로그램이 호출될 때 실행되는 주요 함수
pub fn process_instruction(
    program_id: &Pubkey, // 호출된 프로그램의 공개 키
    accounts: &[AccountInfo], // 프로그램에서 사용할 계정 목록
    _instruction_data: &[u8], // 추가 실행 데이터 (사용되지 않음)
) -> ProgramResult {
    let accounts_iter = &mut accounts.iter(); // 계정 목록을 순회하기 위한 반복자

    // Payer 계정을 가져옴 (서명자)
    let payer_account = next_account_info(accounts_iter)?;
    // Hello 상태 계정을 가져옴
    let hello_state_account = next_account_info(accounts_iter)?;
    // 시스템 프로그램 계정을 가져옴
    let system_program = next_account_info(accounts_iter)?;

    let rent = Rent::get()?; // 현재의 임대료 정보를 가져옴

    // Payer 계정이 서명자인지 확인
    if !payer_account.is_signer {
        return Err(ProgramError::MissingRequiredSignature);
    }

    // Hello 상태 계정이 임대료 면제인지 확인
    if !rent.is_exempt(hello_state_account.lamports(), 1) {
        return Err(ProgramError::AccountNotRentExempt);
    }

    // Hello 상태 계정이 쓰기가 가능한지 확인
    if !hello_state_account.is_writable {
        return Err(ProgramError::InvalidAccountData);
    }

    // Hello 상태 계정의 소유자가 현재 프로그램인지 확인
    if hello_state_account.owner.ne(&program_id) {
        return Err(ProgramError::IllegalOwner);
    }

    // 시스템 프로그램이 예상한 ID와 일치하는지 확인
    if system_program.key.ne(&SYSTEM_PROGRAM_ID) {
        return Err(ProgramError::IncorrectProgramId);
    }

    // Hello 상태 계정에서 데이터를 읽어 HelloState 구조체로 역직렬화
    let mut hello_state = HelloState::try_from_slice(&hello_state_account.data.borrow())?;

    // 상태가 이미 초기화되었는지 확인
    if hello_state.is_initialized {
        return Err(ProgramError::AccountAlreadyInitialized);
    }

    // 상태를 초기화
    hello_state.is_initialized = true;
    // 초기화된 상태를 Hello 상태 계정에 직렬화하여 저장
    hello_state.serialize(&mut &mut hello_state_account.data.borrow_mut()[..])?;
    msg!("Account initialized :)"); // 계정 초기화 메시지 출력

    Ok(()) // 정상적으로 종료
}

// Solana 웹3 라이브러리 및 SPL 토큰 관련 모듈 가져오기
import {
  clusterApiUrl, // 클러스터의 URL을 가져오는 함수
  Connection, // Solana 네트워크와의 연결을 위한 클래스
  Keypair, // 키 쌍을 생성하고 관리하는 클래스
  sendAndConfirmTransaction, // 트랜잭션을 보내고 확인하는 함수
  SystemProgram, // 시스템 프로그램을 통해 계정을 생성하거나 관리하는 기능
  Transaction, // 트랜잭션을 생성하고 조작하는 클래스
} from "@solana/web3.js";
import {
  createInitializeMintInstruction, // 민트 초기화 지시어를 생성하는 함수
  TOKEN_PROGRAM_ID, // SPL 토큰 프로그램의 ID
  MINT_SIZE, // 민트 계정의 크기
  getMinimumBalanceForRentExemptMint, // 임대료 면제 민트를 위한 최소 잔액을 얻는 함수
  createMint, // 민트를 생성하는 함수
} from "@solana/spl-token";
import bs58 from "bs58"; // Base58 인코딩/디코딩을 위한 라이브러리

// 비동기 함수 정의
(async () => {
  // Devnet 클러스터와 연결
  const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
  // 최신 블록 해시 가져오기
  const recentBlockhash = await connection.getLatestBlockhash();

  // 수수료를 지불할 계정 생성 (비밀키를 Base58로 디코딩)
  const feePayer = Keypair.fromSecretKey(
    bs58.decode(
      "588FU4PktJWfGfxtzpAAXywSNt74AvtroVzGfKkVN1LwRuvHwKGr851uH8czM5qm4iqLbs1kKoMKtMJG4ATR7Ld2",
    ),
  );

  // 민트 권한을 가진 계정 생성 (비밀키를 Base58로 디코딩)
  const alice = Keypair.fromSecretKey(
    bs58.decode(
      "4NMwxzmYj2uvHuq8xoqhY8RXg63KSVJM1DXkpbmkUY7YQWuoyQgFnnzn6yo3CMnqZasnNPNuAT2TLwQsCaKkUddp",
    ),
  );

  // 1) 내장 함수를 사용하여 민트 생성
  let mintPubkey = await createMint(
    connection, // 연결 객체
    feePayer, // 수수료 지불자
    alice.publicKey, // 민트 권한
    alice.publicKey, // 동결 권한 (null을 사용하여 비활성화 가능, 비활성화하면 다시 활성화할 수 없음)
    8, // 소수점 자리수
  );
  // 생성된 Mint account의 퍼블릭키 출력
  console.log(`mint: ${mintPubkey.toBase58()}`);

  // 또는

  // 2) 직접 구성하여 민트 생성
  const mint = Keypair.generate(); // 새로운 키 쌍 생성
  console.log(`mint: ${mint.publicKey.toBase58()}`); // 생성된 민트의 퍼블릭키 출력

  // 트랜잭션 생성
  const transaction = new Transaction().add(
    // 민트 계정 생성
    SystemProgram.createAccount({
      fromPubkey: feePayer.publicKey, // 수수료 지불자의 퍼블릭키
      newAccountPubkey: mint.publicKey, // 새로 생성할 민트 계정의 퍼블릭키
      space: MINT_SIZE, // 민트 계정의 크기
      lamports: await getMinimumBalanceForRentExemptMint(connection), // 임대료 면제 민트를 위한 최소 잔액
      programId: TOKEN_PROGRAM_ID, // SPL 토큰 프로그램 ID
    }),
    // 민트 계정 초기화
    createInitializeMintInstruction(
      mint.publicKey, // 민트 계정 퍼블릭키
      8, // 소수점 자리수
      alice.publicKey, // 민트 권한
      alice.publicKey, // 동결 권한
    ),
  );

  // 트랜잭션 전송 및 확인
  const transactionSignature = await sendAndConfirmTransaction(
    connection,
    transaction, // 생성된 트랜잭션
    [feePayer, mint], // 서명자
  );

  // 트랜잭션 해시 출력
  console.log(`txhash: ${transactionSignature}`);
})();

import { clusterApiUrl, Connection, PublicKey } from "@solana/web3.js"; // Solana 관련 모듈 임포트
import { getMint } from "@solana/spl-token"; // SPL 토큰 관련 기능 임포트

(async () => {
  // Solana devnet에 연결
  const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
  
  // 조회할 민트 계정의 공개 키 생성
  const mintAccountPublicKey = new PublicKey(
    "계정 공개 키 값 입력", // 예시 민트 계정의 공개 키
  );

  // 민트 계정 정보 가져오기
  let mintAccount = await getMint(connection, mintAccountPublicKey);

  // 가져온 민트 계정 정보 출력
  console.log(mintAccount);
  /*
  {
    address: PublicKey {
      _bn: <BN: 7351e5e067cc7cfefef42e78915d3c513edbb8adeeab4d9092e814fe68c39fec>
    },
    mintAuthority: PublicKey {
      _bn: <BN: df30e6ca0981c1a677eed6f7cb46b2aa442ca9b7a10a10e494badea4b9b6944f>
    },
    supply: 0n, // 현재 민트된 토큰의 공급량
    decimals: 8, // 소수점 이하 자리 수
    isInitialized: true, // 민트 계정이 초기화되었는지 여부
    freezeAuthority: PublicKey {
      _bn: <BN: df30e6ca0981c1a677eed6f7cb46b2aa442ca9b7a10a10e494badea4b9b6944f>
    } // 동결 권한을 가진 공개 키
  }
  */
})();

// import 생략… (2번 수행함, 전송 테스트 위해서 A, B 생성)
 (async()=> {
   // connection
   const connection= new Connection(clusterApiUrl( "devnet" ), "confirmed" );
 
   const feePayer= getKeypairFromEnvironment( "SECRET_KEY" );
   const mintPubkey= new PublicKey( "9fEVbr7V1VtdorTNg68HWkjtXzDaujWgnLLA4nTgk1oT" ,);
   const myKey= new PublicKey( "3BZy93Tr3wUYmLKwwGkMAKVRLgYMY4mi6reivNdcKuFj" ,);
   
   //     2 ) composed by yourself
   {
     // calculate ATA
     let ata= await getAssociatedTokenAddress(
       mintPubkey,// mint
       myKey,// Second account
     );
     console.log(`ATA: ${ata.toBase58()}`);
  
     let transaction= new Transaction().add(
       createAssociatedTokenAccountInstruction(
         feePayer.publicKey,// payer
         ata,// ata
         myKey,// Second account
         mintPubkey,// mint
       ),
     );
  const signature= await sendAndConfirmTransaction(
       connection,
       transaction,
       [feePayer],// Signers
     );
 
     console.log(`txhash: ${await signature}`);
   }
 })();
 // result CUykwgksaBKTtyuxfhg6b7njdvwqwYkxAuN51G6H7ica
 // result EMUe3nsCWaipWpmaDFypxjXDE6XEYWTSNNKe3tvFEbgx

import { clusterApiUrl, Connection, PublicKey } from "@solana/web3.js" ;
import { getAccount } from "@solana/spl-token" ;
(async()=> {
 const connection= new Connection(clusterApiUrl( "devnet" ), "confirmed" );
 const tokenAccountPubkey= new PublicKey(
   "CUykwgksaBKTtyuxfhg6b7njdvwqwYkxAuN51G6H7ica" ,
 );
 let tokenAccount= await getAccount(connection, tokenAccountPubkey);
 console.log(tokenAccount);
})();

import { clusterApiUrl, Connection, PublicKey } from "@solana/web3.js" ;
(async()=> {
 const connection= new Connection(clusterApiUrl( "devnet" ), "confirmed" );
 const tokenAccount= new PublicKey(
   "CUykwgksaBKTtyuxfhg6b7njdvwqwYkxAuN51G6H7ica" ,
 );
 let tokenAmount= await connection.getTokenAccountBalance(tokenAccount);
 console.log(`amount: ${tokenAmount.value.amount}`);
 console.log(`decimals: ${tokenAmount.value.decimals}`);
})();