contract AlexTextLibrary {
    string public bookTitle = "Приключения в блокчейне";
    string public authorName = "Алекс Разработчик";
    string public motto = "Код - это поэзия будущего!";

    // Функция для объединения текстов
    function createBookInfo() public view returns (string memory) {
        return string(abi.encodePacked(bookTitle, " by ", authorName));
    }
}

function incorrectCompareStrings(string memory a, string memory b) public pure returns (bool) {
    // ❌ Строки нельзя сравнивать напрямую!
    // ❌ Ошибка: Operator == not compatible with types string memory and string memory
    return a == b;
}

function compareStrings(string memory a, string memory b) public pure returns (bool) {
    // ✅ Нужно сравнивать их хеши
    return keccak256(bytes(a)) == keccak256(bytes(b));
}

contract AlexStorageDemo {
    // ✅ Правильно - сложные типы требуют memory
    function setMessage(string memory newMessage) public pure returns (string memory) {
        return newMessage;
    }

    // ✅ Правильно - простые типы НЕ требуют memory
    function calculateSum(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
}

contract AlexBytesLab {
    bytes1 public singleByte = 0x41;  // Буква 'A' в шестнадцатеричном виде
    bytes4 public signature = 0x12345678; // Селектор функции
    bytes32 public hash = keccak256("Alex's secret message"); // Хеш сообщения

    // Динамический массив байтов - требует указания memory в функциях
    bytes public dynamicData = "Hello World!";

    function processData(bytes memory data) public pure returns (bytes memory) {
        return data; // Динамические bytes тоже требуют memory
    }

    function getDataLength() public view returns (uint256) {
        return dynamicData.length; // Длина в байтах
    }
}

contract AlexAddressBook {
    address public myAddress;          // Адрес текущего смарт-контракта
    address public contractCreator;    // Адрес создателя контракта
    address public someUser;           // Адрес пользователя

    constructor() {
        myAddress = address(this);     // Записываем адрес текущего контракта в переменную
        contractCreator = msg.sender;  // msg.sender – кто развернул контракт, аккаунт пользователя
    }

    // Мягкая проверка валидности адреса
    function isValidAddress(address _addr) public pure returns (bool) {
        return _addr != address(0); // Проверяем, что адрес не нулевой
    }

    // Получение баланса эфира на кошельке или смарт-контракте по заданному адресу
    function getBalance(address _addr) public view returns (uint256) {
        return _addr.balance;
    }
}

contract AlexPayableDemo {
    address payable public wallet;     // Кошелек, он может получать эфир
    address payable public owner;      // Адрес владельца, он может получать эфир

    constructor() {
        owner = payable(msg.sender);   // Преобразуем обычный адрес в payable
    }

    // Функция для отправки эфира на payable адрес
    function sendEther(address payable recipient) public payable {
        require(msg.value > 0, "Нужно отправить больше 0 эфира");
        require(recipient != address(0), "Неверный адрес получателя");

        recipient.transfer(msg.value); // Отправляем эфир
    }

    // Вывод всех средств владельцу
    function withdraw() public {
        require(msg.sender == owner, "Только владелец может вывести средства");
        owner.transfer(address(this).balance);
    }

    // Функция для получения эфира
    receive() external payable {
        // Контракт может получать эфир
    }
}

contract AlexAdvancedDataTypes {
    // === ТЕКСТОВЫЕ ТИПЫ ===
    string public userName = "Alex";          // Имя пользователя
    string public projectName = "TokenWorld"; // Название проекта

    // === БАЙТОВЫЕ ТИПЫ ===
    bytes1 public singleByte = 0x41;          // Один байт (буква 'A')
    bytes32 public secretHash = keccak256("MySecret123"); // Хеш секретного сообщения
    bytes public dynamicData = "Hello World!"; // Динамические байты

    // === АДРЕСНЫЕ ТИПЫ ===
    address public contractOwner;             // Владелец контракта
    address payable public treasuryWallet;   // Кошелек для получения эфира

    constructor() {
        contractOwner = msg.sender;           // Устанавливаем владельца
        treasuryWallet = payable(msg.sender); // Устанавливаем payable кошелек
    }

    // Функция для работы со строками
    function updateUserName(string memory newName) public {
        require(msg.sender == contractOwner, "Только владелец может изменить имя");
        userName = newName;
    }

    // Функция для сравнения строк
    function compareNames(string memory name) public view returns (bool) {
        return keccak256(bytes(userName)) == keccak256(bytes(name));
    }

    // Функция для работы с байтами
    function createHash(string memory message) public pure returns (bytes32) {
        return keccak256(bytes(message));
    }

    // Функция для работы с адресами
    function isOwner(address user) public view returns (bool) {
        return user == contractOwner;
    }

    // Функция для получения информации о контракте
    function getContractInfo() public view returns (
        string memory name,
        string memory project,
        address owner,
        bytes32 hash
    ) {
        return (
            userName,
            projectName,
            contractOwner,
            secretHash
        );
    }

    // Функция для работы с динамическими байтами
    function updateDynamicData(bytes memory newData) public {
        require(msg.sender == contractOwner, "Только владелец может обновить данные");
        dynamicData = newData;
    }

    // Функция для получения длины динамических данных
    function getDataLength() public view returns (uint256) {
        return dynamicData.length;
    }
}