// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

/// @title Interface for protocol permissions registry
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
interface IPermissionsManager{
    ///@notice All available roles.
    ///@dev EXT roles are available for future application.
    enum Role {
        ANY,
        GLOBAL_ADMIN,
        MINT_ADMIN,
        TRANSFER_ADMIN,
        SYSTEMS_ADMIN,
        EXT1,
        EXT2,
        EXT3,
        EXT4,
        EXT5,
        EXT6,
        EXT7,
        EXT8,
        EXT9,
        EXT10
    }

    /**
    * @param role_ ISCPermissionsManager.Role to query
    * @param account_ Address to check for role_
    */
    function hasRole(Role role_, address account_) external view returns(bool);

    /**
    * @param role_ ISCPermissionsManager.Role to add
    * @param account_ Address to add role_ on
    */
    function addRole(Role role_, address account_) external;

    /**
    * @param role_ ISCPermissionsManager.Role to remove
    * @param account_ Address to remove role_ from
    */
    function removeRole(Role role_, address account_) external;
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

import "../../interfaces/IPermissionsManager.sol";

contract SCPermissionedAccess {
    IPermissionsManager public immutable permissions;

    /// @notice Function modifier which requires the sender to possess the global admin permission as recorded in "permissions"
    modifier isGlobalAdmin() {
        require(permissions.hasRole(IPermissionsManager.Role.GLOBAL_ADMIN, msg.sender), "Not a Global Admin");
        _;
    }

    /// @notice Function modifier which requires the sender to possess the systems admin permission as recorded in "permissions"
    modifier isSystemsAdmin() {
        require(permissions.hasRole(IPermissionsManager.Role.SYSTEMS_ADMIN, msg.sender), "Not a Systems Admin");
        _;
    }

    constructor(address _permissions){
        permissions = IPermissionsManager(_permissions);
    }
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;
import "../Utils/SCPermissionedAccess.sol";

/// @title SuperChamps Game Events Logger
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
/// @notice A permissioned events logger. Used for tracking virtual asset transactions on chain, via events only.
contract SCVirtualAssetEvents {
    ISCVirtualAssetEventsFactory _factory;
    string public game;

    event GameUserAsset(string user_id, string asset_id, int256 delta, string data);
    event GameUserActivity(string user_id, string data);
    event GameUserAssetWithSign(string user_id, string asset_id, int256 delta, string data, bytes sign);
    event GameUserActivityWithSign(string user_id, string data, bytes sign);

    modifier isPermissionedUser() {
        require(_factory.permissions_users(msg.sender), "NOT PERMISSIONED USER");
        _;
    }

    constructor(ISCVirtualAssetEventsFactory factory_, string memory game_) {
        _factory = factory_;
        game = game_;
    }

    function EmitGameUserAsset(string calldata user_id, string calldata asset_id, int256 delta, string calldata data) external isPermissionedUser {
        emit GameUserAsset(user_id, asset_id, delta, data);
    }

    function EmitGameUserActivity(string calldata user_id, string calldata data) external isPermissionedUser {
        emit GameUserActivity(user_id, data);
    }

    function EmitGameUserAssetWithSign(string calldata user_id, string calldata asset_id, int256 delta, string calldata data, bytes calldata sign) external {
        emit GameUserAssetWithSign(user_id, asset_id, delta, data, sign);
    }

    function EmitGameUserActivityWithSign(string calldata user_id, string calldata data, bytes calldata sign) external {
        emit GameUserActivityWithSign(user_id, data, sign);
    }
}

interface ISCVirtualAssetEventsFactory {
    function permissions_users(address user) external view returns (bool);
}

/// @title SuperChamps Game Events Logger Factory v2
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
/// @notice Used to deploy game specific events loggers. Tracks users who are permissioned to emit events.
contract SCVirtualAssetEventsFactory is SCPermissionedAccess, ISCVirtualAssetEventsFactory {
    mapping(address => bool) public permissions_users;
    mapping(string => SCVirtualAssetEvents) public game_events;
    string[] private _games; 

    constructor(address permissions_) SCPermissionedAccess(permissions_) { 
        _deployGameEvents("Bullet League");
        _deployGameEvents("Racket Rampage");
        _deployGameEvents("Super Champs HQ");
    }

    function permissionUser(address[] memory users, bool state) external isSystemsAdmin {
        uint256 len = users.length;
        for(uint256 i = 0; i < len; i++) {
            permissions_users[users[i]] = state;
        }
    }

    function _deployGameEvents(string memory game_id) internal {
        require(game_events[game_id] == SCVirtualAssetEvents(address(0)), "GAME EXISTS");
        game_events[game_id] = new SCVirtualAssetEvents(this, game_id);
        _games.push(game_id);
    }

    function deployGameEvents(string memory game_id) external isSystemsAdmin {
        _deployGameEvents(game_id);
    }

    function games() external view returns (string[] memory _games_) {
        uint len = _games.length;
        _games_ = new string[](len);
        for(uint i = 0; i < len; i++) {
            _games_[i] = _games[i];
        }
    }
}

{
  "compilationTarget": {
    "SuperChamps/contracts/Ecosystem/SCVirtualAssetEvents.sol": "SCVirtualAssetEvents"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 20
  },
  "remappings": []
}