contract ContractName {
    // Синтаксис объявления переменной состояния:
    тип_данных [модификаторы] имя_переменной [= начальное_значение];

    // Примеры:
    uint256 public balance;                    // Публичная переменная
    string private ownerName;                  // Приватная переменная
    bool internal isActive = true;             // Внутренняя переменная с начальным значением
    address public constant ADMIN = 0x123...; // Публичная константа
    uint256 private immutable creationTime;   // Неизменяемая переменная
}

contract BankAccount {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Все эти переменные хранятся в блокчейне

    string public accountHolder;     // Имя владельца счета
    uint256 public balance;          // Текущий баланс
    bool public isActive;            // Активен ли счет
    address public owner;            // Адрес владельца
    uint256 public lastTransaction;  // Время последней транзакции

    // Эти переменные доступны всем функциям контракта
    function deposit(uint256 amount) public {
        balance += amount;                    // Изменяем переменную состояния
        lastTransaction = block.timestamp;    // Обновляем время
        // Изменения сохранятся в блокчейне навсегда!
    }

    function withdraw(uint256 amount) public {
        require(balance >= amount, "Недостаточно средств");
        balance -= amount;                    // Снова изменяем состояние
        lastTransaction = block.timestamp;    // Время обновляется
        // Все изменения останутся после завершения функции
    }
}

contract GasExample {
    uint256 public stateVariable = 0;

    function expensiveOperations() public {
        // Чтение переменной состояния: ~200 стоимости вызова функции
        uint256 currentValue = stateVariable;

        // Изменение с 0 на не-0: ~20,000 стоимости вызова функции (очень дорого!)
        stateVariable = 100;

        // Изменение с не-0 на не-0: ~5,000 стоимости вызова функции (дорого)
        stateVariable = 200;

        // Изменение с не-0 на 0: ~2,500 стоимости вызова функции + возврат части стоимости вызова функции
        stateVariable = 0;
    }
}

contract ContractName {
    function functionName() public {
        // Синтаксис объявления локальной переменной:
        тип_данных имя_переменной [= начальное_значение];

        // Примеры:
        uint256 temporaryValue;                    // Локальная переменная без начального значения
        string memory userName = "Alex";           // Локальная строка в памяти
        bool isValid = true;                       // Локальная переменная с начальным значением
        address sender = msg.sender;               // Локальная переменная с присвоением
        uint256[] memory numbers = new uint256[](5); // Локальный массив в памяти
    }

contract SyntaxComparison {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    uint256 public stateVar = 100;           // ✅ Можно использовать модификаторы видимости
    string private constant MESSAGE = "Hi";  // ✅ Можно использовать constant

    function exampleFunction() public {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 localVar = 50;               // ✅ Простое объявление
        // uint256 public localPublic = 25;  // ❌ ОШИБКА! Нельзя использовать public
        // uint256 constant LOCAL_CONST = 10; // ❌ ОШИБКА! Нельзя использовать constant
        string memory tempMessage = "Hello"; // ✅ Можно указать memory для сложных типов
    }
}

contract Calculator {
    uint256 public totalCalculations = 0;  // Переменная состояния

    function complexCalculation(uint256 a, uint256 b, uint256 c) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Все эти переменные существуют только во время выполнения функции

        uint256 step1 = a * b;           // Промежуточный результат
        uint256 step2 = step1 + c;       // Еще один промежуточный результат
        uint256 step3 = step2 / 2;       // Финальное вычисление

        bool isEven = step3 % 2 == 0;    // Проверка четности

        if (isEven) {
            uint256 bonus = 10;          // Локальная переменная внутри блока
            step3 += bonus;              // Добавляем бонус
        } // bonus исчезает здесь

        totalCalculations++;             // Изменяем переменную состояния

        return step3;
        // Все локальные переменные (step1, step2, step3, isEven) исчезают здесь!
    }
}

contract GasComparison {
    uint256 public stateResult;  // Переменная состояния

    // ДОРОГОЙ способ — все промежуточные значения в состоянии
    function expensiveWay(uint256 a, uint256 b) public {
        stateResult = a + b;        // ~20,000 стоимости вызова функции (первая запись)
        stateResult = stateResult * 2; // ~5,000 стоимости вызова функции
        stateResult = stateResult - 10; // ~5,000 стоимости вызова функции
        // Общая стоимость: ~30,000 стоимости вызова функции
    }

    // ДЕШЕВЫЙ способ — промежуточные вычисления локально
    function cheapWay(uint256 a, uint256 b) public {
        uint256 temp = a + b;       // ~3 стоимости вызова функции (локальная переменная)
        temp = temp * 2;            // ~3 стоимости вызова функции
        temp = temp - 10;           // ~3 стоимости вызова функции
        stateResult = temp;         // ~20,000 стоимости вызова функции (одна запись в состояние)
        // Общая стоимость: ~20,009 стоимости вызова функции — экономия 33%!
    }
}

contract ScopeExample {
    uint256 public stateVar = 100;  // Переменная состояния — доступна везде в контракте

    function scopeDemo(uint256 param) public pure returns (uint256) {
        uint256 functionVar = 10;   // Доступна во всей функции

        if (param > 5) {
            uint256 blockVar = 20;  // Доступна только в этом блоке if
            functionVar += blockVar; // Можем использовать обе переменные

            {
                uint256 innerVar = 30; // Доступна только в этом внутреннем блоке
                blockVar += innerVar;  // Можем использовать все три
                functionVar += innerVar;
            } // innerVar исчезает здесь

            // innerVar здесь уже недоступна!
            // blockVar все еще доступна

        } // blockVar исчезает здесь

        // Здесь доступны только functionVar и param
        // blockVar и innerVar уже недоступны

        return functionVar;
    } // functionVar и param исчезают здесь
}

contract SimpleBank {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Эта информация должна сохраняться в блокчейне навсегда
    string public bankName = "Alex Bank";   // Название банка
    uint256 public totalBalance;            // Общий баланс банка
    address public owner;                   // Владелец банка
    bool public isOpen = true;              // Работает ли банк

    constructor() {
        owner = msg.sender;  // Устанавливаем владельца
        totalBalance = 0;    // Начальный баланс
    }

    function makeDeposit(uint256 amount) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Эти переменные нужны только для вычислений в этой функции

        uint256 fee = amount / 100;          // Комиссия 1%
        uint256 depositAmount = amount - fee; // Сумма к зачислению
        bool isLargeDeposit = amount > 1000;  // Проверка крупного депозита

        // Если депозит крупный, даем бонус
        if (isLargeDeposit) {
            uint256 bonus = 50;              // Локальная переменная только в этом блоке
            depositAmount += bonus;          // Добавляем бонус
        } // переменная bonus исчезает здесь

        // Обновляем переменную состояния (сохраняется навсегда)
        totalBalance += depositAmount;

        return depositAmount;

        // Все локальные переменные (fee, depositAmount, isLargeDeposit, bonus)
        // исчезают здесь, но totalBalance остается в блокчейне!
    }

    function withdraw(uint256 amount) public returns (bool) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 fee = amount / 50;           // Комиссия за снятие 2%
        uint256 totalCost = amount + fee;    // Общая сумма к списанию
        bool hasEnoughFunds = totalBalance >= totalCost; // Проверка средств

        if (!hasEnoughFunds) {
            return false;  // Недостаточно средств
        }

        // Обновляем состояние (ДОРОГАЯ операция)
        totalBalance -= totalCost;

        return true;

        // Локальные переменные исчезают, но изменения в totalBalance остаются!
    }
}

contract UserProfile {
    // ✅ ПРАВИЛЬНО — эти данные должны сохраняться
    string public userName;
    uint256 public registrationDate;
    uint256 public lastLoginTime;
    bool public isVerified;
}

contract MathOperations {
    uint256 public result;

    function complexCalculation(uint256 a, uint256 b, uint256 c) public {
        // ✅ ПРАВИЛЬНО — промежуточные вычисления локально
        uint256 temp1 = a * b;
        uint256 temp2 = temp1 + c;
        uint256 temp3 = temp2 / 2;

        result = temp3; // Только финальный результат в состояние
    }
}

contract Counter {
    uint256 public count;

    // ❌ ПЛОХО — много записей в состояние
    function badIncrement() public {
        count++;        // Запись 1
        count++;        // Запись 2
        count++;        // Запись 3
    }

    // ✅ ХОРОШО — одна запись в состояние
    function goodIncrement() public {
        uint256 temp = count; // Читаем один раз
        temp += 3;            // Вычисляем локально
        count = temp;         // Записываем один раз
    }
}

contract ScopeOptimization {
    function processData(uint256[] memory data) public pure returns (uint256) {
        uint256 total = 0;

        for (uint256 i = 0; i < data.length; i++) {
            // ✅ ПРАВИЛЬНО — переменная объявлена в нужном месте
            if (data[i] > 10) {
                uint256 bonus = data[i] * 2; // Нужна только здесь
                total += bonus;
            }
        }

        return total;
    }
}