// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

interface IProtocol {
    struct Echo {
        address sender;
        uint64 timestamp;
        uint32 dictIndex;
    }

    struct EchoResult {
        address sender;
        uint64 timestamp;
        string word;
    }

    function dictionary() external view returns (string[] memory);

    function echoesCount() external view returns (uint);

    function echoes(uint index, uint offset) external view returns (EchoResult[] memory);

    function echoesAll() external view returns (EchoResult[] memory);

    function latestEchoes(uint offset) external view returns (EchoResult[] memory);

    function echo(string memory word) external;

    event Echoed(address indexed sender, uint64 timestamp, uint32 dictIndex);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "./IProtocol.sol";

contract Protocol is IProtocol {
    Echo[] private _echoes;
    string[] private _dictionary;
    mapping(string => uint32) private dictionaryIndexMap;

    constructor(string[] memory dictionary_) {
        require(dictionary_.length > 0, "Protocol: Dictionary is empty");
        require(dictionary_.length < 2 ** 32 - 1, "Protocol: Dictionary is too large");

        _dictionary = dictionary_;
        for (uint32 i = 0; i < _dictionary.length; i++) {
            // +1 to differentiate between initialized and uninitialized entries
            dictionaryIndexMap[_dictionary[i]] = i + 1;
        }
    }

    function dictionary() external view override returns (string[] memory) {
        return _dictionary;
    }

    function echoesCount() external view override returns (uint256) {
        return _echoes.length;
    }

    function echoes(uint index, uint offset) public view override returns (EchoResult[] memory) {
        if (index >= _echoes.length) {
            return new EchoResult[](0);
        }
        if (index + offset > _echoes.length) {
            offset = _echoes.length - index;
        }
        EchoResult[] memory result = new EchoResult[](offset);
        for (uint i = 0; i < offset; i++) {
            result[i].sender = _echoes[index + i].sender;
            result[i].timestamp = _echoes[index + i].timestamp;
            result[i].word = _dictionary[_echoes[index + i].dictIndex];
        }
        return result;
    }

    function echoesAll() external view override returns (EchoResult[] memory) {
        return echoes(0, _echoes.length);
    }

    function latestEchoes(uint offset) external view override returns (EchoResult[] memory) {
        if (offset > _echoes.length) {
            offset = _echoes.length;
        }
        return echoes(_echoes.length - offset, offset);
    }

    function echo(string memory word) public override {
        require(bytes(word).length > 0, "Protocol: Word is empty");
        require(dictionaryIndexMap[word] > 0, "Protocol: Word is not in dictionary");

        _echoes.push(Echo(msg.sender, uint64(block.timestamp), dictionaryIndexMap[word] - 1));
        emit Echoed(msg.sender, uint64(block.timestamp), dictionaryIndexMap[word] - 1);
    }

    fallback() external {
        echo(string(msg.data));
    }
}

{
  "compilationTarget": {
    "contracts/Protocol.sol": "Protocol"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "viaIR": true
}