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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract AIOracle is Ownable, ReentrancyGuard {

    uint256 public constant QUERY_FEE = 0.01 ether;

    struct Answer {
        string answer;
        uint8 confidence;
        string reasoning;
        uint256 timestamp;
        bool exists;
    }

    mapping(bytes32 => Answer) public answers;
    mapping(address => bytes32[]) public userQuestions;
    uint256 public totalQuestions;
    uint256 public totalFeesCollected;

    event QuestionAsked(
        bytes32 indexed questionId,
        address indexed asker,
        string question,
        uint256 fee,
        uint256 timestamp
    );

    event AnswerProvided(
        bytes32 indexed questionId,
        string answer,
        uint8 confidence,
        string reasoning,
        uint256 timestamp
    );

    event FeesWithdrawn(
        address indexed owner,
        uint256 amount,
        uint256 timestamp
    );

    /**
     * @dev Constructor sets the deployer as the owner
     */
    constructor() Ownable(msg.sender) {}

    function askOracle(string memory question)
        external
        payable
        nonReentrant
        returns (bytes32 questionId)
    {
        require(msg.value >= QUERY_FEE, "Insufficient fee: 0.01 BNB required");
        require(bytes(question).length > 0, "Question cannot be empty");
        require(bytes(question).length <= 500, "Question too long (max 500 chars)");

        questionId = keccak256(
            abi.encodePacked(
                msg.sender,
                question,
                block.timestamp,
                totalQuestions
            )
        );

        userQuestions[msg.sender].push(questionId);
        totalQuestions++;
        totalFeesCollected += msg.value;

        emit QuestionAsked(
            questionId,
            msg.sender,
            question,
            msg.value,
            block.timestamp
        );

        return questionId;
    }

    function provideAnswer(
        bytes32 questionId,
        string memory answer,
        uint8 confidence,
        string memory reasoning
    )
        external
        onlyOwner
    {
        require(!answers[questionId].exists, "Answer already provided");
        require(bytes(answer).length > 0, "Answer cannot be empty");
        require(confidence <= 100, "Confidence must be 0-100");

        answers[questionId] = Answer({
            answer: answer,
            confidence: confidence,
            reasoning: reasoning,
            timestamp: block.timestamp,
            exists: true
        });

        emit AnswerProvided(
            questionId,
            answer,
            confidence,
            reasoning,
            block.timestamp
        );
    }

    function getAnswer(bytes32 questionId)
        external
        view
        returns (
            string memory answer,
            uint8 confidence,
            string memory reasoning,
            uint256 timestamp
        )
    {
        require(answers[questionId].exists, "Answer not yet provided");

        Answer memory ans = answers[questionId];
        return (ans.answer, ans.confidence, ans.reasoning, ans.timestamp);
    }

    function hasAnswer(bytes32 questionId) external view returns (bool) {
        return answers[questionId].exists;
    }

    function getUserQuestions(address user)
        external
        view
        returns (bytes32[] memory)
    {
        return userQuestions[user];
    }

    function withdraw() external onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        require(balance > 0, "No fees to withdraw");

        emit FeesWithdrawn(msg.sender, balance, block.timestamp);

        (bool success, ) = payable(owner()).call{value: balance}("");
        require(success, "Withdrawal failed");
    }

    function getBalance() external view returns (uint256) {
        return address(this).balance;
    }

    function getStats()
        external
        view
        returns (
            uint256 questions,
            uint256 fees,
            uint256 balance
        )
    {
        return (totalQuestions, totalFeesCollected, address(this).balance);
    }
}