contract AlexHashExplorer {
    // Функция для создания хеша из строки
    function createHash(string memory input) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(input));
    }

    // Демонстрация работы хеш-функции
    function demonstrateHashing() public pure returns (bytes32, bytes32, bytes32) {
        bytes32 hash1 = keccak256(abi.encodePacked("Hello World"));
        bytes32 hash2 = keccak256(abi.encodePacked("Hello World!"));  // Добавили !
        bytes32 hash3 = keccak256(abi.encodePacked("hello world"));   // Маленькими буквами

        // Результаты будут кардинально разными!
        return (hash1, hash2, hash3);
    }

    // Хеширование числовых данных
    function hashNumbers(uint256 number1, uint256 number2) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(number1, number2));
    }

    // Хеширование адреса и суммы (часто используется в токенах)
    function hashTransfer(address from, address to, uint256 amount) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(from, to, amount));
    }
}

contract KeccakExamples {
    // Простое хеширование строки
    function hashString(string memory text) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(text));
    }

    // Хеширование адреса (как создаются адреса контрактов)
    function calculateContractAddress(address deployer, uint256 nonce) public pure returns (address) {
        bytes32 hash = keccak256(abi.encodePacked(deployer, nonce));
        return address(uint160(uint256(hash)));
    }

    // Создание уникального ID для пользователя
    function createUserID(string memory name, address wallet) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(name, wallet, block.timestamp));
    }

    // Создание хеша для проверки целостности данных
    function createDataHash(
        string memory title,
        string memory content,
        address author,
        uint256 timestamp
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(title, content, author, timestamp));
    }
}

contract ShaExamples {
    // SHA-256 стоит больше газа, чем Keccak-256
    function hashWithSha256(string memory input) public pure returns (bytes32) {
        return sha256(abi.encodePacked(input));
    }

    // Сравнение хешей от разных функций
    function compareHashes(string memory input) public pure returns (bytes32, bytes32) {
        bytes32 keccakHash = keccak256(abi.encodePacked(input));
        bytes32 shaHash = sha256(abi.encodePacked(input));
        return (keccakHash, shaHash);
    }

    // Проверка, что документ не изменился
    function verifyDocument(
        string memory content,
        bytes32 originalHash
    ) public pure returns (bool) {
        bytes32 currentHash = sha256(abi.encodePacked(content));
        return currentHash == originalHash;
    }
}

contract AlexDocumentRegistry {
    struct Document {
        string title;
        bytes32 contentHash;    // Хеш содержимого
        address author;
        uint256 timestamp;
        bool exists;
    }

    mapping(bytes32 => Document) public documents;
    mapping(address => bytes32[]) public userDocuments;

    event DocumentRegistered(bytes32 indexed documentId, address indexed author, string title);
    event DocumentVerified(bytes32 indexed documentId, bool isValid);

    // Регистрируем документ в системе
    function registerDocument(
        string memory title,
        string memory content
    ) public returns (bytes32) {
        // Создаем хеш содержимого для проверки целостности
        bytes32 contentHash = keccak256(abi.encodePacked(content));

        // Создаем уникальный ID документа
        bytes32 documentId = keccak256(abi.encodePacked(
            title,
            contentHash,
            msg.sender,
            block.timestamp
        ));

        // Сохраняем документ
        documents[documentId] = Document({
            title: title,
            contentHash: contentHash,
            author: msg.sender,
            timestamp: block.timestamp,
            exists: true
        });

        // Добавляем к списку документов пользователя
        userDocuments[msg.sender].push(documentId);

        emit DocumentRegistered(documentId, msg.sender, title);
        return documentId;
    }

    // Проверяем, не был ли документ изменен
    function verifyDocument(
        bytes32 documentId,
        string memory currentContent
    ) public returns (bool) {
        require(documents[documentId].exists, "Документ не найден");

        bytes32 currentHash = keccak256(abi.encodePacked(currentContent));
        bool isValid = currentHash == documents[documentId].contentHash;

        emit DocumentVerified(documentId, isValid);
        return isValid;
    }

    // Получаем информацию о документе
    function getDocumentInfo(bytes32 documentId) public view returns (
        string memory title,
        address author,
        uint256 timestamp,
        bytes32 contentHash
    ) {
        require(documents[documentId].exists, "Документ не найден");
        Document memory doc = documents[documentId];
        return (doc.title, doc.author, doc.timestamp, doc.contentHash);
    }

    // Получаем все документы пользователя
    function getUserDocuments(address user) public view returns (bytes32[] memory) {
        return userDocuments[user];
    }
}

contract UniqueIdentifiers {
    // Создание ID заказа
    function createOrderId(
        address buyer,
        address seller,
        uint256 amount,
        uint256 timestamp
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(buyer, seller, amount, timestamp));
    }

    // Создание ID транзакции
    function createTransactionId(
        address from,
        address to,
        uint256 value,
        uint256 nonce
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(from, to, value, nonce));
    }
}

contract PasswordProtection {
    mapping(address => bytes32) private passwordHashes;

    // Установка пароля (сохраняем только хеш!)
    function setPassword(string memory password) public {
        passwordHashes[msg.sender] = keccak256(abi.encodePacked(password));
    }

    // Проверка пароля
    function checkPassword(string memory password) public view returns (bool) {
        bytes32 inputHash = keccak256(abi.encodePacked(password));
        return inputHash == passwordHashes[msg.sender];
    }

    // Изменение пароля
    function changePassword(
        string memory oldPassword,
        string memory newPassword
    ) public {
        require(checkPassword(oldPassword), "Неверный старый пароль");
        passwordHashes[msg.sender] = keccak256(abi.encodePacked(newPassword));
    }
}

contract AccessTokens {
    mapping(bytes32 => bool) public validTokens;
    mapping(bytes32 => uint256) public tokenExpiry;

    // Создание временного токена
    function createAccessToken(
        address user,
        uint256 duration
    ) public returns (bytes32) {
        bytes32 token = keccak256(abi.encodePacked(
            user,
            block.timestamp,
            block.difficulty,
            msg.sender
        ));

        validTokens[token] = true;
        tokenExpiry[token] = block.timestamp + duration;

        return token;
    }

    // Проверка токена
    function isValidToken(bytes32 token) public view returns (bool) {
        return validTokens[token] && block.timestamp <= tokenExpiry[token];
    }

    // Отзыв токена
    function revokeToken(bytes32 token) public {
        validTokens[token] = false;
    }
}

contract HashingSecurity {
    // ✅ ПРАВИЛЬНО: используем abi.encodePacked для простых типов
    function safeHash1(address user, uint256 amount) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(user, amount));
    }

    // ✅ ПРАВИЛЬНО: используем abi.encode для сложных структур
    function safeHash2(string memory text, uint256[] memory numbers) public pure returns (bytes32) {
        return keccak256(abi.encode(text, numbers));
    }

    // ⚠️ ОСТОРОЖНО: возможны коллизии при неправильном порядке
    function potentialCollision(string memory a, string memory b) public pure returns (bytes32) {
        // "ab" + "c" и "a" + "bc" дадут одинаковый результат!
        return keccak256(abi.encodePacked(a, b));
    }

    // ✅ РЕШЕНИЕ: добавляем разделители или используем abi.encode
    function safeStringHash(string memory a, string memory b) public pure returns (bytes32) {
        return keccak256(abi.encode(a, b)); // Безопасно!
    }
}

contract GasEfficiency {
    // Keccak-256 - самый дешевый (30 газа + 6 за каждое слово)
    function cheapHash(bytes memory data) public pure returns (bytes32) {
        return keccak256(data);
    }

    // SHA-256 - дороже (60 газа + 12 за каждое слово)
    function expensiveHash(bytes memory data) public pure returns (bytes32) {
        return sha256(data);
    }

    // RIPEMD-160 - самый дорогой (600 газа + 120 за каждое слово)
    function mostExpensiveHash(bytes memory data) public pure returns (bytes20) {
        return ripemd160(data);
    }
}