// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

/**
 * BasePool 0.2
 * miniapp de Farcaster que usa Pyth Network para generación de numeros aleatorios
 * basado en ApeBomb de 0xQuit
 * https://x.com/0xQuit
 * https://apescan.io/address/0xC1932844eDcc3193ae2622089c4B57ae5F023D7f
 */

import {IEntropy} from "@pythnetwork/entropy-sdk-solidity/IEntropy.sol";
import {IEntropyConsumer} from "@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

struct Pool {
    uint256 nextNumberToAssign;
    mapping(uint256 explicitNumber => address participant) explicitNumbers;
}

contract BasePool is IEntropyConsumer, Ownable {
    error InvalidAmount();
    error TransferFailed();
    error TargetExceeded();
    error EmergencyWithdrawNotYetRequested();
    error EmergencyWithdrawNotYetAvailable();

    event Participation(
        uint256 indexed poolId, 
        address indexed participant, 
        uint256 startNumber, 
        uint256 endNumber
    );
    event ConquerorSelected(
        uint256 indexed poolId, 
        address indexed conqueror, 
        uint256 amount
    );
    event EmergencyWithdrawRequested(uint256 emergencyWithdrawTimestamp);

    /* testnet
    *IEntropy public constant ENTROPY = IEntropy(0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c);
    *address public constant PROVIDER = 0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344;
    */

    // mainnet
    IEntropy public constant ENTROPY = IEntropy(0x6E7D74FA7d5c90FEF9F0512987605a6d546181Bb);
    address public constant PROVIDER = 0x52DeaA1c84233F7bb8C8A45baeDE41091c616506;
    

    mapping(uint256 poolId => Pool pool) public pools;
    mapping(uint256 poolId => uint256) public conqueredNumbers;

    uint256 public currentPoolId;
    uint256 public emergencyWithdrawTimestamp;
    address private immutable FEE_WALLET;

    uint256 private constant ENTRY_COST = 0.0005 ether;
    uint256 private constant POOL_TARGET = 0.5 ether; // 1000 números * 0.0005 ETH
    uint256 public constant FEE_RATE = 50; // 5%

    constructor() Ownable(msg.sender) {
        FEE_WALLET = msg.sender;
    }

    // asignamos un número al participar
    receive() external payable {
        _enter();
    }

    /**
     * función de retiro de fondos en caso de que pyth deje de funcionar
     * tiempo de espera = 1 año a partir de la fecha de la solicitud
     * si el pool se cierra antes de que se cumpla el tiempo de espera, la solicitud se resetea
     */
    function requestEmergencyWithdraw() external onlyOwner {
        emergencyWithdrawTimestamp = block.timestamp + 365 days;

        emit EmergencyWithdrawRequested(emergencyWithdrawTimestamp);
    }

    function fulfillEmergencyWithdraw() external onlyOwner {
        if (emergencyWithdrawTimestamp == 0) revert EmergencyWithdrawNotYetRequested();
        if (block.timestamp < emergencyWithdrawTimestamp) revert EmergencyWithdrawNotYetAvailable();

        (bool success,) = msg.sender.call{value: address(this).balance}("");
        if (!success) revert TransferFailed();
    }

    function entropyCallback(uint64, /* sequenceNumber */ address, /* provider */ bytes32 randomNumber)
        internal
        override
    {
        if (address(this).balance < POOL_TARGET) return;

        uint256 random = uint256(randomNumber);
        uint256 selectedNumber = random % pools[currentPoolId].nextNumberToAssign;

        // guardamos el número conquistado
        conqueredNumbers[currentPoolId] = selectedNumber;

        address participant = _findParticipant(selectedNumber);
        if (participant == address(0)) return;

        // calculamos montos a enviar
        uint256 totalAmount = address(this).balance;
        uint256 commission = (totalAmount * FEE_RATE) / 1000;
        uint256 prize = totalAmount - commission;

        // transferimos balance al número seleccionado
        (bool successConqueror,) = participant.call{value: prize}("");
        if (!successConqueror) revert TransferFailed();

        // transferimos al owner del pool
        (bool successFee,) = FEE_WALLET.call{value: commission}("");
        if (!successFee) revert TransferFailed();

        emit ConquerorSelected(currentPoolId, participant, prize);

        emergencyWithdrawTimestamp = 0;

        unchecked {
            ++currentPoolId;
        }
    }

    function _enter() internal {
        // validamos que el monto sea divisible por ENTRY_COST
        if (msg.value == 0 || msg.value % ENTRY_COST != 0) revert InvalidAmount();

        uint256 numNumbers = msg.value / ENTRY_COST;

        _assignNumber(numNumbers);

        // pagamos las comisiones y solicitamos un numero aleatorio de entropy si llegamos al target
        if (address(this).balance >= POOL_TARGET) {
            bytes32 pseudoRandomNumber =
                keccak256(abi.encode(block.timestamp, block.number, msg.sender, address(this).balance));

            uint128 requestFee = ENTROPY.getFee(PROVIDER);

            ENTROPY.requestWithCallback{value: requestFee}(PROVIDER, pseudoRandomNumber);
        }
    }

    function getEntropy() internal pure override returns (address) {
        return address(ENTROPY);
    }

    function _assignNumber(uint256 numNumbers) internal {
        uint256 startNumber = pools[currentPoolId].nextNumberToAssign;

        // asignamos cada numero individualmente
        for (uint256 i = 0; i < numNumbers; i++) {
            pools[currentPoolId].explicitNumbers[startNumber + i] = msg.sender;
        }

        uint256 nextNumberToAssign = startNumber + numNumbers;
        pools[currentPoolId].nextNumberToAssign = nextNumberToAssign;

        emit Participation(currentPoolId, msg.sender, startNumber, nextNumberToAssign - 1);
    }

    function _findParticipant(uint256 number) internal view returns (address) {
        for (uint256 i = number; i >= 0; --i) {
            address participant = pools[currentPoolId].explicitNumbers[i];
            if (participant != address(0)) {
                return participant;
            }

            if (i == 0) {
                return address(0);
            }
        }

        return address(0);
    }

    // consulta para el estado actual del pool -> visible en basescan
    function getPoolStatus() external view returns (
        uint256 poolId,
        uint256 totalNumbers,
        uint256 currentBalance,
        uint256 threshold
    ) {
        return (
            currentPoolId,
            pools[currentPoolId].nextNumberToAssign,
            address(this).balance,
            POOL_TARGET
        );
    }

    // consulta de números asignados por dirección -> visible en basescan
    function getParticipantNumbers(address participant) external view returns (uint256[] memory) {
        uint256[] memory numbers = new uint256[](pools[currentPoolId].nextNumberToAssign);
        uint256 count = 0;

        for (uint256 i = 0; i < pools[currentPoolId].nextNumberToAssign; i++) {
            if (pools[currentPoolId].explicitNumbers[i] == participant) {
                numbers[count] = i;
                count++;
            }
        }

        uint256[] memory result = new uint256[](count);
        for (uint256 i = 0; i < count; i++) {
            result[i] = numbers[i];
        }

        return result;
    }

    // consulta de números por dirección -> visible en basescan
    function getParticipantNumberCount(address participant) external view returns (uint256) {
        uint256 count = 0;
        Pool storage pool = pools[currentPoolId];
        
        for (uint256 i = 0; i < pool.nextNumberToAssign; i++) {
            if (pool.explicitNumbers[i] == participant) {
                count++;
            }
        }
        
        return count;
    }

    // consulta de número conquistado de un pool específico -> visible en basescan
    function getConqueredNumber(uint256 poolId) external view returns (uint256) {
        return conqueredNumbers[poolId];
    }

    // consulta de todos los números conquistados -> visible en basescan
    function getAllConqueredNumbers() external view returns (uint256[] memory) {
        uint256[] memory numbers = new uint256[](currentPoolId);
        for (uint256 i = 0; i < currentPoolId; i++) {
            numbers[i] = conqueredNumbers[i];
        }
        return numbers;
    }
}
/**
 * BasePool 0.2
 * miniapp de Farcaster que usa Pyth Network para generación de numeros aleatorios
 * basado en ApeBomb de 0xQuit
 * https://x.com/0xQuit
 * https://apescan.io/address/0xC1932844eDcc3193ae2622089c4B57ae5F023D7f
 */

// 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;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

import "./EntropyStructs.sol";

interface EntropyEvents {
    event Registered(EntropyStructs.ProviderInfo provider);

    event Requested(EntropyStructs.Request request);
    event RequestedWithCallback(
        address indexed provider,
        address indexed requestor,
        uint64 indexed sequenceNumber,
        bytes32 userRandomNumber,
        EntropyStructs.Request request
    );

    event Revealed(
        EntropyStructs.Request request,
        bytes32 userRevelation,
        bytes32 providerRevelation,
        bytes32 blockHash,
        bytes32 randomNumber
    );
    event RevealedWithCallback(
        EntropyStructs.Request request,
        bytes32 userRandomNumber,
        bytes32 providerRevelation,
        bytes32 randomNumber
    );

    event ProviderFeeUpdated(address provider, uint128 oldFee, uint128 newFee);

    event ProviderUriUpdated(address provider, bytes oldUri, bytes newUri);

    event ProviderFeeManagerUpdated(
        address provider,
        address oldFeeManager,
        address newFeeManager
    );

    event Withdrawal(
        address provider,
        address recipient,
        uint128 withdrawnAmount
    );
}

// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.0;

contract EntropyStructs {
    struct ProviderInfo {
        uint128 feeInWei;
        uint128 accruedFeesInWei;
        // The commitment that the provider posted to the blockchain, and the sequence number
        // where they committed to this. This value is not advanced after the provider commits,
        // and instead is stored to help providers track where they are in the hash chain.
        bytes32 originalCommitment;
        uint64 originalCommitmentSequenceNumber;
        // Metadata for the current commitment. Providers may optionally use this field to help
        // manage rotations (i.e., to pick the sequence number from the correct hash chain).
        bytes commitmentMetadata;
        // Optional URI where clients can retrieve revelations for the provider.
        // Client SDKs can use this field to automatically determine how to retrieve random values for each provider.
        // TODO: specify the API that must be implemented at this URI
        bytes uri;
        // The first sequence number that is *not* included in the current commitment (i.e., an exclusive end index).
        // The contract maintains the invariant that sequenceNumber <= endSequenceNumber.
        // If sequenceNumber == endSequenceNumber, the provider must rotate their commitment to add additional random values.
        uint64 endSequenceNumber;
        // The sequence number that will be assigned to the next inbound user request.
        uint64 sequenceNumber;
        // The current commitment represents an index/value in the provider's hash chain.
        // These values are used to verify requests for future sequence numbers. Note that
        // currentCommitmentSequenceNumber < sequenceNumber.
        //
        // The currentCommitment advances forward through the provider's hash chain as values
        // are revealed on-chain.
        bytes32 currentCommitment;
        uint64 currentCommitmentSequenceNumber;
        // An address that is authorized to set / withdraw fees on behalf of this provider.
        address feeManager;
    }

    struct Request {
        // Storage slot 1 //
        address provider;
        uint64 sequenceNumber;
        // The number of hashes required to verify the provider revelation.
        uint32 numHashes;
        // Storage slot 2 //
        // The commitment is keccak256(userCommitment, providerCommitment). Storing the hash instead of both saves 20k gas by
        // eliminating 1 store.
        bytes32 commitment;
        // Storage slot 3 //
        // The number of the block where this request was created.
        // Note that we're using a uint64 such that we have an additional space for an address and other fields in
        // this storage slot. Although block.number returns a uint256, 64 bits should be plenty to index all of the
        // blocks ever generated.
        uint64 blockNumber;
        // The address that requested this random number.
        address requester;
        // If true, incorporate the blockhash of blockNumber into the generated random value.
        bool useBlockhash;
        // If true, the requester will be called back with the generated random value.
        bool isRequestWithCallback;
        // There are 2 remaining bytes of free space in this slot.
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.0;

import "./EntropyEvents.sol";

interface IEntropy is EntropyEvents {
    // Register msg.sender as a randomness provider. The arguments are the provider's configuration parameters
    // and initial commitment. Re-registering the same provider rotates the provider's commitment (and updates
    // the feeInWei).
    //
    // chainLength is the number of values in the hash chain *including* the commitment, that is, chainLength >= 1.
    function register(
        uint128 feeInWei,
        bytes32 commitment,
        bytes calldata commitmentMetadata,
        uint64 chainLength,
        bytes calldata uri
    ) external;

    // Withdraw a portion of the accumulated fees for the provider msg.sender.
    // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient
    // balance of fees in the contract).
    function withdraw(uint128 amount) external;

    // Withdraw a portion of the accumulated fees for provider. The msg.sender must be the fee manager for this provider.
    // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient
    // balance of fees in the contract).
    function withdrawAsFeeManager(address provider, uint128 amount) external;

    // As a user, request a random number from `provider`. Prior to calling this method, the user should
    // generate a random number x and keep it secret. The user should then compute hash(x) and pass that
    // as the userCommitment argument. (You may call the constructUserCommitment method to compute the hash.)
    //
    // This method returns a sequence number. The user should pass this sequence number to
    // their chosen provider (the exact method for doing so will depend on the provider) to retrieve the provider's
    // number. The user should then call fulfillRequest to construct the final random number.
    //
    // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value.
    // Note that excess value is *not* refunded to the caller.
    function request(
        address provider,
        bytes32 userCommitment,
        bool useBlockHash
    ) external payable returns (uint64 assignedSequenceNumber);

    // Request a random number. The method expects the provider address and a secret random number
    // in the arguments. It returns a sequence number.
    //
    // The address calling this function should be a contract that inherits from the IEntropyConsumer interface.
    // The `entropyCallback` method on that interface will receive a callback with the generated random number.
    //
    // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value.
    // Note that excess value is *not* refunded to the caller.
    function requestWithCallback(
        address provider,
        bytes32 userRandomNumber
    ) external payable returns (uint64 assignedSequenceNumber);

    // Fulfill a request for a random number. This method validates the provided userRandomness and provider's proof
    // against the corresponding commitments in the in-flight request. If both values are validated, this function returns
    // the corresponding random number.
    //
    // Note that this function can only be called once per in-flight request. Calling this function deletes the stored
    // request information (so that the contract doesn't use a linear amount of storage in the number of requests).
    // If you need to use the returned random number more than once, you are responsible for storing it.
    function reveal(
        address provider,
        uint64 sequenceNumber,
        bytes32 userRevelation,
        bytes32 providerRevelation
    ) external returns (bytes32 randomNumber);

    // Fulfill a request for a random number. This method validates the provided userRandomness
    // and provider's revelation against the corresponding commitment in the in-flight request. If both values are validated
    // and the requestor address is a contract address, this function calls the requester's entropyCallback method with the
    // sequence number, provider address and the random number as arguments. Else if the requestor is an EOA, it won't call it.
    //
    // Note that this function can only be called once per in-flight request. Calling this function deletes the stored
    // request information (so that the contract doesn't use a linear amount of storage in the number of requests).
    // If you need to use the returned random number more than once, you are responsible for storing it.
    //
    // Anyone can call this method to fulfill a request, but the callback will only be made to the original requester.
    function revealWithCallback(
        address provider,
        uint64 sequenceNumber,
        bytes32 userRandomNumber,
        bytes32 providerRevelation
    ) external;

    function getProviderInfo(
        address provider
    ) external view returns (EntropyStructs.ProviderInfo memory info);

    function getDefaultProvider() external view returns (address provider);

    function getRequest(
        address provider,
        uint64 sequenceNumber
    ) external view returns (EntropyStructs.Request memory req);

    function getFee(address provider) external view returns (uint128 feeAmount);

    function getAccruedPythFees()
        external
        view
        returns (uint128 accruedPythFeesInWei);

    function setProviderFee(uint128 newFeeInWei) external;

    function setProviderFeeAsFeeManager(
        address provider,
        uint128 newFeeInWei
    ) external;

    function setProviderUri(bytes calldata newUri) external;

    // Set manager as the fee manager for the provider msg.sender.
    // After calling this function, manager will be able to set the provider's fees and withdraw them.
    // Only one address can be the fee manager for a provider at a time -- calling this function again with a new value
    // will override the previous value. Call this function with the all-zero address to disable the fee manager role.
    function setFeeManager(address manager) external;

    function constructUserCommitment(
        bytes32 userRandomness
    ) external pure returns (bytes32 userCommitment);

    function combineRandomValues(
        bytes32 userRandomness,
        bytes32 providerRandomness,
        bytes32 blockHash
    ) external pure returns (bytes32 combinedRandomness);
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.0;

abstract contract IEntropyConsumer {
    // This method is called by Entropy to provide the random number to the consumer.
    // It asserts that the msg.sender is the Entropy contract. It is not meant to be
    // override by the consumer.
    function _entropyCallback(
        uint64 sequence,
        address provider,
        bytes32 randomNumber
    ) external {
        address entropy = getEntropy();
        require(entropy != address(0), "Entropy address not set");
        require(msg.sender == entropy, "Only Entropy can call this function");

        entropyCallback(sequence, provider, randomNumber);
    }

    // getEntropy returns Entropy contract address. The method is being used to check that the
    // callback is indeed from Entropy contract. The consumer is expected to implement this method.
    // Entropy address can be found here - https://docs.pyth.network/entropy/contract-addresses
    function getEntropy() internal view virtual returns (address);

    // This method is expected to be implemented by the consumer to handle the random number.
    // It will be called by _entropyCallback after _entropyCallback ensures that the call is
    // indeed from Entropy contract.
    function entropyCallback(
        uint64 sequence,
        address provider,
        bytes32 randomNumber
    ) internal virtual;
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

{
  "compilationTarget": {
    "contracts/BasePool/BasePool.sol": "BasePool"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}