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

import {IFeeManager} from "./IFeeManager.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/// @title GmBoost - Per-user GM contract (clone) that accepts ETH, splits value,
///         forwards platform share immediately, and accrues owner share for withdrawal.
/// @author GmBoost Team
/// @notice Deploy via Factory as an ERC-1167 minimal proxy pointing to this implementation.
contract GmBoost is ReentrancyGuard {
    // -------------------------- Custom Errors --------------------------
    error AlreadyInitialized();
    error ZeroAddress();
    error NotOwner();
    error InsufficientEth();
    error TransferFailed();
    error UnauthorizedCaller();
    error NothingToWithdraw();

    // ---------------------------- Storage ------------------------------
    /// @notice The user who owns this GM contract.
    address public owner;
    /// @notice Address of FeeManager providing config.
    address public feeManager;
    /// @notice Factory that deployed this implementation.
    address public immutable FACTORY;
    uint16 private constant _BPS_DENOMINATOR = 10_000;
    bool private _initialized;   // One-time initializer guard

    // ---------------------------- Events -------------------------------
    /// @notice Emitted whenever a GM is sent on-chain.
    /// @param sender        The caller who sent the GM (pays msg.value)
    /// @param value         The total ETH sent with the call (tips included)
    /// @param requiredWei   The required minimum at the time of call (from FeeManager)
    /// @param platformShare The amount forwarded to the platform treasury
    /// @param ownerShare    The amount retained in this contract for the owner
    event OnChainGM(
        address indexed sender,
        uint256 value,
        uint256 requiredWei,
        uint256 platformShare,
        uint256 ownerShare
    ); // solhint-disable-line gas-indexed-events

    /// @notice Emitted when owner withdraws accumulated funds
    /// @param owner Address of the owner who withdrew
    /// @param amount Amount withdrawn in wei
    event OwnerWithdrawn(address indexed owner, uint256 amount); // solhint-disable-line gas-indexed-events

    // -------------------------- Constructor ----------------------------
    /// @notice Locks the implementation contract and records the factory address.
    /// @dev Clones use their own storage, so this only affects the implementation.
    ///      The factory address is used to authorize clone initialization.
    /// @param factory_ The address of the GmBoostFactory that will create clones
    constructor(address factory_) {
        if (factory_ == address(0)) revert ZeroAddress();
        _initialized = true;
        FACTORY = factory_;
    }

    // --------------------------- Initializer ---------------------------
    /// @notice Must be called exactly once by the Factory right after cloning.
    /// @dev Custom initialization guard (equivalent to OpenZeppelin Initializable):
    ///      - Implementation locked in constructor (prevents initialization attack on implementation)
    ///      - _initialized flag prevents double initialization on clones
    ///      - Factory-only authorization provides ADDITIONAL protection beyond standard OZ pattern
    ///      - Only the factory can initialize clones to prevent unauthorized deployments
    ///        that could bypass deployment fees or use malicious FeeManager contracts
    ///      - No external dependencies, lower gas costs than inherited Initializable
    /// @param owner_ Address of the contract owner
    /// @param feeManager_ Address of the FeeManager contract
    function initialize(address owner_, address feeManager_) external {
        if (msg.sender != FACTORY) revert UnauthorizedCaller();
        if (_initialized) revert AlreadyInitialized();
        if (owner_ == address(0) || feeManager_ == address(0)) revert ZeroAddress();
        owner = owner_;
        feeManager = feeManager_;
        _initialized = true;
    }

    // --------------------------- Core Logic ----------------------------
    /// @notice Send a GM. Requires at least the configured ETH fee; tips allowed.
    /// @dev No reentrancy guard needed - follows CEI pattern strictly:
    ///      1. Checks (fee validation)
    ///      2. Effects (state is already finalized before external call)
    ///      3. Interactions (external call to feeRecipient)
    ///      Reentrancy cannot exploit as no state writes occur after the call.
    /// Splits full msg.value into platformShare (forwarded now) and ownerShare (retained).
    function onChainGM() external payable {
        // 1) Read config from FeeManager (single STATICCALL)
        (uint256 requiredWei, uint16 ownerShareBps, address feeRecipient) =
            IFeeManager(feeManager).getConfig();

        // Extra safety: feeRecipient should never be zero (guarded in FeeManager) but validate here
        if (feeRecipient == address(0)) revert ZeroAddress();

        // 2) Enforce minimum fee (tips allowed)
        if (msg.value < requiredWei) revert InsufficientEth();

        // 3) Compute split
        //    ownerShare = floor(msg.value * bps / 10_000)
        uint256 ownerShare = (msg.value * ownerShareBps) / _BPS_DENOMINATOR;
        uint256 platformShare = msg.value - ownerShare;

        // 4) Forward platform share now (single external call)
        if (platformShare != 0) {
            // Safe: feeRecipient from FeeManager (Safe multisig controlled, not user input)
            // CEI pattern enforced, explicit success check, no state writes after external call
            (bool ok, ) = payable(feeRecipient).call{value: platformShare}("");
            if (!ok) revert TransferFailed();
        }

        // 5) Owner share is intentionally left in this contract (no transfer here)

        // 6) Emit event (transparent on-chain receipt)
        emit OnChainGM(msg.sender, msg.value, requiredWei, platformShare, ownerShare);
    }

    /// @notice Owner withdraws entire accrued balance (pull model).
    function withdrawOwner() external nonReentrant {
        if (msg.sender != owner) revert NotOwner();
        uint256 bal = address(this).balance;
        if (bal == 0) revert NothingToWithdraw();
        // Safe: owner withdrawing to self (onlyOwner check above, nonReentrant guard on function)
        // ReentrancyGuard + owner validation + balance check before external call
        (bool ok, ) = payable(owner).call{value: bal}("");
        if (!ok) revert TransferFailed();
        emit OwnerWithdrawn(owner, bal);
    }

    // ------------------------- Receive Fallback ------------------------
    /// @notice Accepts ETH sent directly (counted toward owner's balance).
    receive() external payable {}
}

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

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

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

/// @title IFeeManager - Interface for reading the current GM payout/fee config
/// @author GmBoost Team
/// @notice Exposes read-only accessors for GM fee and deployment settings.
interface IFeeManager {
    /// @notice Returns the current configuration used by GM contracts.
    /// @return ethFeeWei  The minimum ETH required to call onChainGM (tips allowed).
    /// @return ownerShareBps  The owner's share in basis points (0..10_000).
    /// @return feeRecipient  The platform treasury receiving the platform share.
    function getConfig()
        external
        view
        returns (uint256 ethFeeWei, uint16 ownerShareBps, address feeRecipient);

    /// @notice Returns deployment configuration used by the Factory.
    /// @return deployFeeWei  The ETH fee required to deploy a GM contract (tips allowed).
    /// @return feeRecipient  The platform treasury receiving deployment fees.
    function getDeployConfig()
        external
        view
        returns (uint256 deployFeeWei, address feeRecipient);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

[{"inputs":[{"internalType":"address","name":"factory_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"InsufficientEth","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[],"name":"NothingToWithdraw","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"UnauthorizedCaller","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"requiredWei","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"platformShare","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownerShare","type":"uint256"}],"name":"OnChainGM","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"OwnerWithdrawn","type":"event"},{"inputs":[],"name":"FACTORY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"feeManager_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"onChainGM","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]