// SampleContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import "./interfaces/IAIOracle.sol";

/// @notice A base contract for writing a AIOracle app
abstract contract AIOracleCallbackReceiver {

    // Address of the AIOracle contract
    IAIOracle public immutable aiOracle;

    // Invalid callback source error
    error UnauthorizedCallbackSource(IAIOracle expected, IAIOracle found);

    /// @notice Initialize the contract, binding it to a specified AIOracle contract
    constructor(IAIOracle _aiOracle) {
        aiOracle = _aiOracle;
    }

    /// @notice Verify this is a callback by the aiOracle contract 
    modifier onlyAIOracleCallback() {
        IAIOracle foundRelayAddress = IAIOracle(msg.sender);
        if (foundRelayAddress != aiOracle) {
            revert UnauthorizedCallbackSource(aiOracle, foundRelayAddress);
        }
        _;
    }

    /**
     * @dev the callback function in OAO, should add the modifier onlyAIOracleCallback!
     * @param requestId Id for the request in OAO (unique per request)
     * @param output AI model's output
     * @param callbackData user-defined data (The same as when the user call aiOracle.requestCallback)
     */
    function aiOracleCallback(uint256 requestId, bytes calldata output, bytes calldata callbackData) external virtual;

    function isFinalized(uint256 requestId) external view returns (bool) {
        return aiOracle.isFinalized(requestId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SampleContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

interface IAIOracle {
    /// @notice Event emitted upon receiving a callback request through requestCallback.
    event AICallbackRequest(
        address indexed account,
        uint256 indexed requestId,
        uint256 modelId,
        bytes input,
        address callbackContract,
        uint64 gasLimit,
        bytes callbackData
    );

    /// @notice Event emitted when the result is uploaded or update.
    event AICallbackResult(
        address indexed account,
        uint256 indexed requestId,
        address invoker,
        bytes output
    );

    /**
     * initiate a request in OAO
     * @param modelId ID for AI model
     * @param input input for AI model
     * @param callbackContract address of callback contract
     * @param gasLimit gas limitation of calling the callback function
     * @param callbackData optional, user-defined data, will send back to the callback function
     * @return requestID
     */
    function requestCallback(
        uint256 modelId,
        bytes memory input,
        address callbackContract,
        uint64 gasLimit,
        bytes memory callbackData
    ) external payable returns (uint256);

    function estimateFee(uint256 modelId, uint256 gasLimit) external view returns (uint256);

    function isFinalized(uint256 requestId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

import {IAIOracle} from "OAO/contracts/interfaces/IAIOracle.sol";
import {AIOracleCallbackReceiver} from "OAO/contracts/AIOracleCallbackReceiver.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

/// @notice User interfacing contract that interacts with OAO
/// @dev Prompt contract inherits AIOracleCallbackReceiver, so that OPML nodes can callback with the result.
contract Prompt is AIOracleCallbackReceiver, Pausable {
    event promptsUpdated(
        uint256 requestId,
        uint256 modelId,
        string input,
        string output,
        bytes callbackData
    );

    event ScoreUpdated(address indexed user, uint8 newScore);

    event promptRequest(
        uint256 requestId,
        address sender,
        uint256 modelId,
        string prompt
    );

    struct AIOracleRequest {
        address sender;
        uint256 modelId;
        bytes input;
        bytes output;
    }

    address public owner;

    string private systemPrompt =
        "7007 protocol tokenizes AI outputs as unique inference  assets, each representing a specific AI-generated data piece. This protocol makes AI inferences verifiable, immutable, and non-fungible, securing data and computation integrity on the blockchain. You are rating community members engagement with and potential to improve a crypto project. Rate replies based on: 0-10: The reply does not contribute value or is unclear/incomplete/short. 20-50: The member only wants financial incentive only but provides insufficient details to introduce their potential contribution. 60-90: The member could potentially improve the project and explains their plans and contribution convincingly. 90-100: The reply shows special passion and benefits for the project. You must output only the score in the format: ";

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }

    /// @dev requestId => AIOracleRequest
    mapping(uint256 => AIOracleRequest) public requests;

    /// @dev modelId => callback gasLimit
    mapping(uint256 => uint64) public callbackGasLimit;

    // @dev address => score
    mapping(address => uint8) public addressScore;

    address[] public scoredAddresses;

    mapping(address => bool) public isAddressScored;

    /// @notice Initialize the contract, binding it to a specified AIOracle.
    constructor(IAIOracle _aiOracle) AIOracleCallbackReceiver(_aiOracle) {
        owner = msg.sender;
        callbackGasLimit[14] = 2_500_000; // score checking
    }

    /// @notice sets the callback gas limit for a model
    /// @dev only owner can set the gas limit
    function setCallbackGasLimit(
        uint256 modelId,
        uint64 gasLimit
    ) external onlyOwner {
        callbackGasLimit[modelId] = gasLimit;
    }

    /// @dev uint256: modelID => (string: prompt => string: output)
    mapping(uint256 => mapping(string => string)) public prompts;

    /// @notice returns the output for the specified model and prompt
    function getAIResult(
        uint256 modelId,
        string calldata prompt
    ) external view returns (string memory) {
        string memory input = string(
            abi.encodePacked(
                '{"instruction":"',
                systemPrompt,
                '",',
                '"input": "',
                prompt,
                '"}'
            )
        );
        return prompts[modelId][input];
    }

    /// @notice Pause the contract
    function pause() external onlyOwner {
        _pause();
    }

    /// @notice Unpause the contract
    function unpause() external onlyOwner {
        _unpause();
    }

    /// @notice OAO executes this method after it finishes with computation
    /// @param requestId id of the request
    /// @param output result of the OAO computation
    /// @param callbackData optional data that is executed in the callback
    function aiOracleCallback(
        uint256 requestId,
        bytes calldata output,
        bytes calldata callbackData
    ) external override onlyAIOracleCallback {
        // since we do not set the callbackData in this example, the callbackData should be empty
        AIOracleRequest storage request = requests[requestId];
        require(request.sender != address(0), "request does not exist");
        request.output = output;
        prompts[request.modelId][string(request.input)] = string(output);

        uint8 outputScore = safelyConvertToScore(output);
        address sender = request.sender;
        addressScore[sender] = outputScore;
        emit ScoreUpdated(sender, outputScore);

        if (!isAddressScored[sender]) {
            scoredAddresses.push(sender);
            isAddressScored[sender] = true;
        }

        emit promptsUpdated(
            requestId,
            request.modelId,
            string(request.input),
            string(output),
            callbackData
        );
    }

    function safelyConvertToScore(bytes memory b) public pure returns (uint8) {
        if (b.length == 0) return 50;

        uint16 score = 0;
        bool hasValidDigit = false;

        for (uint i = 0; i < b.length; i++) {
            uint8 currentByte = uint8(b[i]);

            if (currentByte >= 48 && currentByte <= 57) {
                if (score == 0 && currentByte == 48 && !hasValidDigit) {
                    continue;
                }
                hasValidDigit = true;
                score = score * 10 + (currentByte - 48);

                if (score > 100) {
                    return 50;
                }
            } else if (hasValidDigit) {
                break;
            }
        }

        if (!hasValidDigit) {
            return 50;
        }

        return uint8(score);
    }

    function getWhitelist() public view returns (address[] memory) {
        return scoredAddresses;
    }

    function getWhitelistLength() public view returns (uint256) {
        return scoredAddresses.length;
    }

    /// @notice estimating fee that is spent by OAO
    function estimateFee(uint256 modelId) public view returns (uint256) {
        return aiOracle.estimateFee(modelId, callbackGasLimit[modelId]);
    }

    function setSystemPrompt(string calldata _systemPrompt) external onlyOwner {
        systemPrompt = _systemPrompt;
    }

    uint256 public startTime = 1725879600;
    uint256 public endTime = 1726052400;
    function getStartTime() public view returns (uint256) {
        return startTime;
    }

    function getEndTime() public view returns (uint256) {
        return endTime;
    }

    function getStartRemainingTime() public view returns (uint256) {
        require(block.timestamp >= startTime, "Claim Token Phase Not Open");
        return startTime - block.timestamp;
    }

    function getEndRemainingTime() public view returns (uint256) {
        require(block.timestamp <= endTime, "Claim Token Phase Ended");
        return endTime - block.timestamp;
    }

    function setStartTime(uint256 _startTime) public onlyOwner {
        startTime = _startTime;
    }

    function setEndTime(uint256 _endTime) public onlyOwner {
        endTime = _endTime;
    }

    /// @notice main point of interaction with OAO
    /// @dev aiOracle.requestCallback sends request to OAO
    function calculateAIResult(
        uint256 modelId,
        string calldata prompt
    ) external payable whenNotPaused returns (uint256) {
        require(block.timestamp >= startTime, "Phase Not Open");
        require(block.timestamp <= endTime, "Phase Ended");
        bytes memory input = bytes(
            abi.encodePacked(
                '{"instruction":"',
                systemPrompt,
                '",',
                '"input": "',
                prompt,
                '"}'
            )
        );
        uint256 requestId = aiOracle.requestCallback{value: msg.value}(
            modelId,
            input,
            address(this),
            callbackGasLimit[modelId],
            ""
        );
        AIOracleRequest storage request = requests[requestId];
        request.input = input;
        request.sender = msg.sender;
        request.modelId = modelId;
        emit promptRequest(requestId, msg.sender, modelId, prompt);
        return requestId;
    }
}

{
  "compilationTarget": {
    "src/Prompt.sol": "Prompt"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    ":@prb-math/=lib/prb-math/src/",
    ":@prb/math/=lib/prb-math/src/",
    ":@prb/test/=lib/prb-math/lib/prb-test/src/",
    ":OAO/=lib/OAO/",
    ":ds-test/=lib/prb-math/lib/forge-std/lib/ds-test/src/",
    ":forge-std/=lib/forge-std/src/",
    ":prb-math/=lib/prb-math/src/",
    ":prb-test/=lib/prb-math/lib/prb-test/src/",
    ":src/=src/"
  ]
}