// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

contract MyContract {
    // 컨트랙트 코드 작성
}

contract StorageExample {
    uint256 public myNumber = 42;       // 숫자
    string public myText = "Hello";      // 텍스트
    bool public isActive = true;         // true/false 값
    address public owner;                // 이더리움 주소
    uint256 private secretNumber;        // private 숫자
}

uint256 public counter = 0;           // counter() 함수 자동 생성
uint256 private password = 123456;    // 다른 컨트랙트에서 접근 불가
uint256 internal sharedSecret = 42;   // 자식 컨트랙트에서 접근 가능

contract TokenContract {
    uint256 public constant DECIMAL_PLACES = 18;
    string public constant TOKEN_NAME = "My Token";
    address public constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
}

contract TokenContract {
    address public immutable deployer;
    uint256 public immutable deploymentTime;

    constructor() {
        deployer = msg.sender;
        deploymentTime = block.timestamp;
    }
}

uint a = 5;
uint b = a;    // b는 5의 복사본을 가짐
b = 10;        // a는 여전히 5, b는 10

struct Person {
    string name;
    uint256 age;
    address walletAddress;
}

contract PointerExample {
    uint256[] public storageArray = [1, 2, 3];

    function manipulateArray() public {
        // storage 배열에 대한 포인터 생성
        uint256[] storage storageArrayPointer = storageArray;

        // 포인터를 통해 실제 storage 배열 수정
        storageArrayPointer[0] = 100;
        // storageArray는 이제 [100, 2, 3]

        // memory에 복사본 생성 (포인터가 아님)
        uint256[] memory memoryArray = storageArray;

        // memory 복사본만 수정, storage 배열은 변경 안됨
        memoryArray[1] = 200;
        // storageArray는 여전히 [100, 2, 3]
        // memoryArray는 [100, 200, 3]
    }
}

uint256[] permanentArray;  // storage에 저장

function processArray(uint256[] calldata inputValues) external {
    // inputValues는 calldata에 존재 - 수정 불가

    // memory의 지역 변수 - 임시 복사본
    uint256[] memory tempArray = new uint256[](inputValues.length);
    for (uint i = 0; i < inputValues.length; i++) {
        tempArray[i] = inputValues[i] * 2;
    }

    // storage 참조 - 변경 사항이 영구 저장됨
    uint256[] storage myStorageArray = permanentArray;
    myStorageArray.push(tempArray[0]);
}

contract Counter {
    uint256 public count = 0;

    function increment() public {
        count = count + 1;  // count += 1; 도 가능
    }

    function decrement() public {
        count = count - 1;  // count -= 1; 도 가능
    }
}

function add(uint256 a, uint256 b) public pure returns (uint256) {
    return a + b;
}

function getCount() public view returns (uint256) {
    return count;
}

function addNumbers(uint256 a, uint256 b) public pure returns (uint256) {
    return a + b;
}

constructor() {
    owner = msg.sender;
}

mapping(address => uint256) balances;

function sendMeMoney() public payable {
    balances[msg.sender] += msg.value;
}

contract OwnerExample {
    address public owner;

    constructor() {
        owner = msg.sender;  // 배포자가 owner가 됨
    }
}

contract PaymentExample {
    mapping(address => uint256) public payments;

    function makePayment() public payable {
        require(msg.value > 0, "Must send some ETH");
        payments[msg.sender] += msg.value;
    }
}

contract DataExample {
    bytes public lastCallData;

    function recordCallData() public {
        lastCallData = msg.data;
    }
}

contract TimestampExample {
    uint256 public contractCreationTime;

    constructor() {
        contractCreationTime = block.timestamp;
    }

    function hasDurationPassed(uint256 durationInSeconds) public view returns (bool) {
        return (block.timestamp >= contractCreationTime + durationInSeconds);
    }
}

contract BlockNumberExample {
    uint256 public deploymentBlockNumber;

    constructor() {
        deploymentBlockNumber = block.number;
    }

    function getBlocksPassed() public view returns (uint256) {
        return block.number - deploymentBlockNumber;
    }
}

contract TimeLockedWallet {
    address public owner;
    uint256 public unlockTime;

    event Deposit(address indexed sender, uint256 amount, uint256 timestamp);
    event Withdrawal(uint256 amount, uint256 timestamp);

    constructor(uint256 _unlockDuration) {
        owner = msg.sender;
        unlockTime = block.timestamp + _unlockDuration;
    }

    function deposit() public payable {
        require(msg.value > 0, "Must deposit some ETH");
        emit Deposit(msg.sender, msg.value, block.timestamp);
    }

    function withdraw() public {
        require(msg.sender == owner, "You are not the owner");
        require(block.timestamp >= unlockTime, "Funds are still locked");
        require(address(this).balance > 0, "No funds to withdraw");

        uint256 balance = address(this).balance;
        payable(owner).transfer(balance);

        emit Withdrawal(balance, block.timestamp);
    }

    function withdrawalStatus() public view returns (bool canWithdraw, uint256 remainingTime) {
        if (block.timestamp >= unlockTime) {
            return (true, 0);
        } else {
            return (false, unlockTime - block.timestamp);
        }
    }
}

function checkValue(uint256 value) public pure returns (string memory) {
    if (value > 100) {
        return "Value is greater than 100";
    } else if (value == 100) {
        return "Value is exactly 100";
    } else {
        return "Value is less than 100";
    }
}

function sumArray(uint256[] memory numbers) public pure returns (uint256) {
    uint256 total = 0;

    for (uint i = 0; i < numbers.length; i++) {
        total += numbers[i];
    }

    return total;
}

function withdraw(uint256 amount) public {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    balances[msg.sender] -= amount;
    payable(msg.sender).transfer(amount);
}

error InsufficientBalance(address user, uint256 balance, uint256 withdrawAmount);

function withdraw(uint256 amount) public {
    if (balances[msg.sender] < amount) {
        revert InsufficientBalance(msg.sender, balances[msg.sender], amount);
    }
    balances[msg.sender] -= amount;
    payable(msg.sender).transfer(amount);
}

contract Token {
    event Transfer(address indexed from, address indexed to, uint256 amount);

    mapping(address => uint256) public balances;

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        balances[msg.sender] -= amount;
        balances[to] += amount;

        emit Transfer(msg.sender, to, amount);
    }
}

contract Owned {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;  // 이 자리표시자가 함수 코드로 대체됨
    }

    function setOwner(address newOwner) public onlyOwner {
        owner = newOwner;
    }
}

interface IPayable {
    function pay(address recipient, uint256 amount) external returns (bool);
    function getBalance(address account) external view returns (uint256);
}

contract PaymentProcessor is IPayable {
    mapping(address => uint256) private balances;

    function pay(address recipient, uint256 amount) external override returns (bool) {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[recipient] += amount;
        return true;
    }

    function getBalance(address account) external view override returns (uint256) {
        return balances[account];
    }
}

// Solidity 스마트 컨트랙트
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleMath {
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
}

[
  {
    "inputs": [
      { "internalType": "uint256", "name": "a", "type": "uint256" },
      { "internalType": "uint256", "name": "b", "type": "uint256" }
    ],
    "name": "add",
    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
    "stateMutability": "pure",
    "type": "function"
  }
]

const contract = new ethers.Contract(contractAddress, contractABI, provider);
await contract.deposit(100);