// Вход: два числа → Черный ящик (функция) → Выход: произведение чисел
function multiply(uint256 a, uint256 b) public pure returns (uint256) {
    return a * b;  // Внутренняя логика скрыта от пользователя
}

function setTokenPrice(uint256 newPrice) public returns (bool) {
    //     ↑             ↑                      ↑         ↑
    //   имя        параметры             модификаторы   что возвращает

    // тело функции - что она делает.
    // Здесь – присваивает новое значение переменной состояния
    tokenPrice = newPrice;

    // возвращаемое значение
    return true;
}

function имя_функции(тип_параметра имя_параметра) модификаторы returns (тип_возврата) {
    // тело функции

    // возвращаемое значение
    return значение;
}

function transferTokens(address to, uint256 amount, string memory reason) public {
    //                    ↑        ↑               ↑
    //                  адрес   количество     причина перевода
}

function getBalance(address user) public view returns (uint256) {
    //                                               ↑
    //                                         возвращает число
    return balances[user];
}

contract TokenContract {
    // Вместо одной огромной функции — много маленьких и понятных
    function validateTransfer(address from, address to, uint256 amount) internal pure returns (bool) {
        // Проверка валидности перевода
    }

    function updateBalances(address from, address to, uint256 amount) internal {
        // Обновление балансов
    }

    function transfer(address to, uint256 amount) public {
        require(validateTransfer(msg.sender, to, amount), "Invalid transfer");
        updateBalances(msg.sender, to, amount);
    }
}

contract GameContract {
    function calculateDamage(uint256 baseDamage, uint256 multiplier) public pure returns (uint256) {
        return baseDamage * multiplier / 100;
    }

    function swordAttack(uint256 strength) public pure returns (uint256) {
        return calculateDamage(strength, 120);  // Переиспользуем функцию
    }

    function magicAttack(uint256 intelligence) public pure returns (uint256) {
        return calculateDamage(intelligence, 150);  // И снова переиспользуем
    }
}

contract Example {
    uint256 public counter;

    // Создает транзакцию! Стоит газ, записывается в блокчейн
    function increment() public {
        counter += 1;
    }

    // НЕ создает транзакцию! Бесплатно, выполняется локально
    function getCounter() public view returns (uint256) {
        return counter;
    }
}

// ✅ Правильно - строка требует указания memory
function setMessage(string memory newMessage) public {
    message = newMessage;
}

// ✅ Правильно - строка требует указания memory при возврате
function getMessage() public view returns (string memory) {
    return message;
}

// ✅ Правильно - простые типы НЕ требуют memory
function incrementCounter() public {
    counter = counter + 1;  // uint256 не требует memory
}

// ❌ Ошибка - без memory компилятор не поймет, где хранить строку
function setMessage(string newMessage) public {  // ОШИБКА!
    message = newMessage;
}

// Основные операции с балансом, они могут быть нужны и внутри, и снаружи смарт-контракта
function getBalance() public view returns (uint256) {
    return balance;
}

// Перевод средств
function transfer(address to, uint256 amount) public {
    // логика перевода
}

// Пополнение счёта
function deposit() public payable {
    balance += msg.value;
}

// Получение информации о контракте
function getContractInfo() public view returns (string memory) {
    return "My Smart Contract";
}

// Внутренние вычисления
function _calculateFee(uint256 amount) private pure returns (uint256) {
    return amount * 3 / 100; // 3% комиссия
}

// Проверка внутренних условий
function _isValidUser(address user) private view returns (bool) {
    return userBalances[user] > 0;
}

// Сброс внутренних данных
function _resetCounters() private {
    dailyTransactions = 0;
    weeklyLimit = 1000;
}

// Базовая логика переводов, которая может быть расширена наследниками
function _transfer(address from, address to, uint256 amount) internal {
    balances[from] -= amount;
    balances[to] += amount;
}

// Общие проверки, могут быть переиспользованы для дочерних контрактов
function _validateAmount(uint256 amount) internal pure returns (bool) {
    return amount > 0 && amount < 1000000;
}

// Инициализация для наследуемых контрактов
function _initialize(address owner) internal {
    contractOwner = owner;
    isInitialized = true;
}

// Административные функции
function emergencyStop() external {
    require(msg.sender == admin, "Only admin");
    paused = true;
}

// Функции обратного вызова (callbacks)
function onTokenReceived(address from, uint256 amount, bytes calldata data) external {
    // Вызывается другими контрактами
}

// API для внешних вызовов с большими данными
function processLargeData(uint256[] calldata numbers) external {
    // экономичнее для больших массивов
}

contract Example {
    uint256 public counter = 10;  // Создается автоматически:

    // function counter() public view returns (uint256) {
    //     return counter;
    // }
}

contract Example {
    function incrementCounter() public {  // Можно вызвать извне И изнутри
        // логика функции
    }

    function internalHelper() internal {  // Только изнутри контракта
        incrementCounter();  // Это работает
    }
}

// Получение баланса пользователя
function getBalance(address user) public view returns (uint256) {
    return balances[user];
}

// Проверка разрешений
function isOwner(address user) public view returns (bool) {
    return user == owner;
}

// Получение информации о блокчейне
function getCurrentTime() public view returns (uint256) {
    return block.timestamp;
}

// Расчёты на основе текущих данных
function calculateInterest(address user) public view returns (uint256) {
    return balances[user] * interestRate / 100;
}

// Математические вычисления
function add(uint256 a, uint256 b) public pure returns (uint256) {
    return a + b;
}

// Расчёт процентов
function calculateInterest(uint256 amount, uint256 rate) public pure returns (uint256) {
    return amount * rate / 100;
}

// Работа со строками
function concatenate(string memory a, string memory b) public pure returns (string memory) {
    return string(abi.encodePacked(a, " ", b));
}

// Валидация данных
function isValidEmail(string memory email) public pure returns (bool) {
    bytes memory emailBytes = bytes(email);
    return emailBytes.length > 5; // Упрощённая проверка
}

// Пополнение счёта
function deposit() public payable {
    balances[msg.sender] += msg.value; // msg.value - отправленная сумма ETH
}

// Покупка товара
function buyItem(uint256 itemId) public payable {
    require(msg.value >= itemPrices[itemId], "Insufficient payment");
    // Логика покупки
}

// Донаты с сообщением
function donate(string memory message) public payable {
    require(msg.value > 0, "Donation must be greater than 0");
    totalDonations += msg.value;
}

// Конструктор может быть payable
constructor() public payable {
    owner = msg.sender;
    // Можно отправить ETH при деплое
}

contract TokenSaleVault {
    uint256 public tokenPrice = 0.001 ether;
    uint256 public userTokenBalance;

    // Pure: мы не читаем переменные состояния
    function calculateTokens(uint256 ethAmount) public pure returns (uint256) {
        return ethAmount / 0.001 ether;
    }

    // View: только чтение переменной состояния – balances[user]
    function getBalance(address user) public view returns (uint256) {
        return userTokenBalance;
    }

    // Payable: получение платежа и изменение состояния
    function buyTokens() public payable {
        require(msg.value > 0, "Send ETH to buy tokens");
        uint256 tokens = calculateTokens(msg.value);
        userTokenBalance += tokens;
    }

    // ...
}

contract Example {
    uint256 private data = 42;

    // Комбинация: external + view. Не изменяет состояние и можно вызвать только снаружи
    function getData() external view returns (uint256) {
        return data;
    }

    // Комбинация: public + payable. Можно вызывать внутри и снаружи, и функция может принимать ETH
    function deposit() public payable {
        // Функция доступна всем И может получать платежи
    }

    // Комбинация: internal + pure. Вызов только изнутри, не читает и не изменяет состояние
    function helper(uint256 x) internal pure returns (uint256) {
        return x * 2;
    }
}

function cube(uint256 input) public pure returns (uint256) {
    // Только вычисляем значение на основе аргументов. Не читаем и не изменяем переменные состояния контракта.
    uint256 output = input * input * input;
    return output;
}

contract Calculator {
    uint256 public lastResult;

    function getLastResult() public view returns (uint256) {
        return lastResult;  // Только читаем, не изменяем
    }
}

contract Counter {
    uint256 public count;

    function increment() public {
        count = count + 1;  // Изменяем состояние контракта
    }
}

contract Donation {
    uint256 public totalDonations;

    function donate() public payable {
        totalDonations += msg.value;  // Получаем и учитываем платеж
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract HelloWorld {
    string public message = "Привет, мир!";

    // Функция для изменения сообщения
    function setMessage(string memory newMessage) public {
        message = newMessage;
    }

    // Функция для получения сообщения
    function getMessage() public view returns (string memory) {
        return message;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Counter {
    uint256 public counter = 0;  // Переменная, которая хранится в блокчейне

    function incrementCounter() public {
        counter = counter + 1;  // Пользователи могут увеличить счетчик
    }
}