// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

interface Interface {
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

contract PortfolioAdmin is Initializable, OwnableUpgradeable, UUPSUpgradeable, ERC165 {
    event SetSuperOperator(string operator, address superOperator, bool enabled);

    // operator => who => valid
    struct SuperOperators {
        mapping(address => bool) who;
        string operator;
    }

    mapping(string => SuperOperators) public _superOperators;

    constructor() {
        _disableInitializers();
    }

    function initialize() public initializer {
        __UUPSUpgradeable_init();
        __Ownable_init();
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC165) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

    function setSuperOperator(string memory operator, address[] memory _operatorAddress, bool enabled) external onlyOwner {
        for (uint8 i = 0; i < _operatorAddress.length;) {
            _superOperators[operator].operator = operator;
            _superOperators[operator].who[_operatorAddress[i]] = enabled;
            emit SetSuperOperator(operator, _operatorAddress[i], enabled);
            unchecked { ++i; }
        }
    }

    function setSuperOperators(string[] memory operators, address[][] memory _operatorAddresses, bool enabled) external onlyOwner {
        for (uint8 i = 0; i < operators.length; i++) {
            _superOperators[operators[i]].operator = operators[i];
            for (uint8 j = 0; j < _operatorAddresses[i].length; j++) {
                _superOperators[operators[i]].who[_operatorAddresses[i][j]] = enabled;
                emit SetSuperOperator(operators[i], _operatorAddresses[i][j], enabled);
            }
        }
    }

    function isSuperOperator(string memory operator, address who) public view returns (bool) {
        return _superOperators[operator].who[who];
    }

    uint256[30] private __PortfolioAdminGap;
}

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

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract PortfolioAuthority is Initializable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {

    mapping (address => bool) blacklist;

    event Blacklist(address userAddress, uint256 timestamp, bool live);

    constructor() {
        _disableInitializers();
    }

    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    function isBlacklist(address user) public view returns (bool) {
        return blacklist[user];
    }

    function setBlacklist(address[] memory userAddresses, bool _isBlacklist) external onlySuperOperator {
        for (uint8 i = 0; i < userAddresses.length;) {
            blacklist[userAddresses[i]] = _isBlacklist;
            emit Blacklist(userAddresses[i], block.timestamp, _isBlacklist);
            unchecked { ++i; }
        }
    }

    uint256[30] private __PortfolioAuthorityGap;
}

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

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract PortfolioService is Initializable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {

    mapping(address => bool) isInspection;

    event Inspection(address contractAddress, uint256 timestamp, bool live);

    constructor() {
        _disableInitializers();
    }

    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    function isLive(address contractAddress) public view returns (bool) {
        return !isInspection[contractAddress];
    }

    function setInspection(address[] memory contractAddresses, bool _isInspection) external onlySuperOperator {
        for (uint8 i = 0; i < contractAddresses.length;) {
            isInspection[contractAddresses[i]] = _isInspection;
            emit Inspection(contractAddresses[i], block.timestamp, _isInspection);
            unchecked { ++i; }
        }
    }

    uint256[30] private __LuxonServiceGap;
}

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

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract DataAddress is Initializable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {

    event SetDataAddress(string indexed name, address indexed dataAddress, bool indexed isValid);

    struct DataAddressInfo {
        string name;
        address dataAddress;
        bool isValid;
    }

    mapping(string => DataAddressInfo) private dataAddresses;

    constructor() {
        _disableInitializers();
    }

    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    function getDataAddress(string memory _name) public view returns (address) {
        require(dataAddresses[_name].isValid, "this data address is not valid");
        return dataAddresses[_name].dataAddress;
    }

    function setDataAddress(DataAddressInfo memory _dataAddressInfo) external onlySuperOperator {
        dataAddresses[_dataAddressInfo.name] = _dataAddressInfo;
        emit SetDataAddress(_dataAddressInfo.name, _dataAddressInfo.dataAddress, _dataAddressInfo.isValid);
    }

    function setDataAddresses(DataAddressInfo[] memory _dataAddressInfos) external onlySuperOperator {
        for (uint8 i = 0; i < _dataAddressInfos.length;) {
            dataAddresses[_dataAddressInfos[i].name] = _dataAddressInfos[i];
            emit SetDataAddress(_dataAddressInfos[i].name, _dataAddressInfos[i].dataAddress, _dataAddressInfos[i].isValid);
            unchecked { ++i; }
        }
    }

    uint256[30] private __DataAddressGap;
}

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

import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";

contract PortfolioCenter is ERC1155Holder {
    function name() public pure returns (string memory) {
        return "Portfolio Center";
    }
}

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

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract AdminAirdropCoin is Initializable, ReentrancyGuardUpgradeable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {
    event AirdropCoin(address indexed receiver, uint256 amount);
    event Withdraw(address indexed to, uint256 amount);
    event Deposit(address indexed from, uint256 amount);

    constructor() {
        _disableInitializers();
    }

    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __ReentrancyGuard_init();
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    struct AirdropInfo {
        address receiver;
        uint256 amount; // ETH 단위 (Wei로 자동 변환됨)
    }

    function airdrop(AirdropInfo[] memory airdropInfos) external onlySuperOperator nonReentrant {
        uint256 length = airdropInfos.length;
        require(length > 0, "Empty array");
        require(length <= 500, "Too many recipients");

        uint256 totalAmount = 0;

        // 1단계: 유효성 검증 및 총액 계산
        for (uint256 i = 0; i < length; ) {
            require(airdropInfos[i].receiver != address(0), "Invalid address");
            require(airdropInfos[i].amount > 0, "Invalid amount");

            uint256 amountInWei = airdropInfos[i].amount * 10 ** 18;
            totalAmount += amountInWei;

            unchecked { ++i; }
        }

        require(address(this).balance >= totalAmount, "Insufficient balance");

        // 2단계: 전송 실행
        for (uint256 i = 0; i < length; ) {
            address payable recipient = payable(airdropInfos[i].receiver);
            uint256 amountInWei = airdropInfos[i].amount * 10 ** 18;

            (bool success, ) = recipient.call{value: amountInWei}("");
            require(success, "Transfer failed");

            emit AirdropCoin(recipient, amountInWei);

            unchecked { ++i; }
        }
    }

    function charging() external payable onlySuperOperator {
        require(msg.value > 0, "Invalid amount");
        emit Deposit(msg.sender, msg.value);
    }

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

        (bool success, ) = msg.sender.call{value: balance}("");
        require(success, "Transfer failed");

        emit Withdraw(msg.sender, balance);
    }

    function withdrawAmount(uint256 amount) external onlySuperOperator nonReentrant {
        require(amount > 0, "Invalid amount");
        require(address(this).balance >= amount, "Insufficient balance");

        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        emit Withdraw(msg.sender, amount);
    }

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

    receive() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    uint256[30] private __AdminAirdropCoinGap;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

enum GachaType {
    None,
    Shapes,
    Number
}

struct GachaDto {
    uint256 tokenId;
    string name;
    GachaType gachaType;
    uint32[] tierRatio;
    bool isValid;
}

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

struct TransferRequest {
    address from;
    address[] tos;
    uint256[] tokenIds;
}

struct IDBurn {
    address owner;
    uint256[] tokenIds;
}

struct Mint {
    address to;
    uint256 quantity;
}

struct IDMint {
    address to;
    uint256[] tokenIds;
}

struct ShapeStruct {
    uint256 tokenId;
    uint32 shapeId;
}

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

interface IErc1155Token {
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
    function mint(address account, uint256 id, uint256 amount, bytes memory data) external;
    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) external;
    function balanceOf(address account, uint256 id) external returns (uint256);
    function burn(address account, uint256 id, uint256 value) external;
    function burnBatch(address account, uint256[] memory ids, uint256[] memory values) external;
    function safeMint(address to, uint256 id, uint256 value, bytes memory data) external;
}

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

import "../admin/management/DataAddress.sol";
import "../data/gacha/GachaData.sol";
import "../data/number/NumberData.sol";
import "../token/erc1155/IErc1155Token.sol";
import "../token/erc721/IShapeToken.sol";
import "../utils/PortfolioBlacklist.sol";
import "../utils/PortfolioDataUpgradeable.sol";
import "../utils/PortfolioLive.sol";
import "../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";

contract GachaMachine is Initializable, ReentrancyGuardUpgradeable, ERC1155Holder, PortfolioLive, PortfolioDataUpgradeable, PortfolioSuperOperatorsUpgradeable, PortfolioBlacklist, UUPSUpgradeable {
    event GachaShape(address indexed owner, uint256 indexed gachaTokenId, uint256 indexed tokenId, uint256 requestId);
    event GachaNumber(address indexed owner, uint256 indexed gachaTokenId, uint256 indexed tokenId);

    struct UsedGoods {
        uint256 tokenId;
        uint256 amount;
    }

    address private shapeAddress;
    address private numberAddress;
    address private gachaAddress;
    address private gachaDataAddress;
    address private numberDataAddress;

    function gachaByGachaToken(UsedGoods memory _gachaInfo) external nonReentrant isLive isBlacklist {
        GachaDto memory gachaDto = mintPay(_gachaInfo);

        if (gachaDto.gachaType == GachaType.Shapes) {
            mintShape(_gachaInfo);
        } else if (gachaDto.gachaType == GachaType.Number) {
            mintNumber(_gachaInfo);
        }
    }

    function mintPay(UsedGoods memory _gachaInfo) private returns (GachaDto memory) {
        GachaDto memory gachaDto = GachaData(gachaDataAddress).getGachaInfo(_gachaInfo.tokenId);
        require(gachaDto.isValid, "not valid token id");
        IErc1155Token(gachaAddress).burn(msg.sender, _gachaInfo.tokenId, _gachaInfo.amount);
        return gachaDto;
    }

    function mintShape(UsedGoods memory _gachaInfo) private {
        IShapeToken(shapeAddress).mintByQuantity(msg.sender, _gachaInfo.amount);
        uint256 lastTokenId = IShapeToken(shapeAddress).nextTokenId() - 1;
        for (uint256 i = 0; i < _gachaInfo.amount;) {
            uint256 tokenId = lastTokenId - _gachaInfo.amount + i + 1;
            uint256 requestId = 0; // Chainlink VRF 사용 시 활성화
            emit GachaShape(msg.sender, _gachaInfo.tokenId, tokenId, requestId);
            unchecked { ++i; }
        }
    }

    function mintNumber(UsedGoods memory _gachaInfo) private {
        require(_gachaInfo.amount <= 100, "Exceed max gacha amount");
        (uint32[] memory _tierRatio, uint32 _tierRatioSum) = GachaData(gachaDataAddress).getGachaTierRatio(_gachaInfo.tokenId);

        for (uint32 i = 0; i < _gachaInfo.amount;) {
            bytes32 combinedSeed = keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp, block.number, msg.sender, tx.gasprice, i));
            uint8 tier = uint8(randomNumber(combinedSeed, i, _tierRatio, _tierRatioSum, "number") + 1);
            uint256 count = NumberData(numberDataAddress).getNumberInfoByTireCount(tier);
            uint32 index = uint32(uint256(keccak256(abi.encodePacked(combinedSeed, i, "index"))) % count);
            uint256 tokenId = NumberData(numberDataAddress).getNumberInfoByTireAndIndex(tier, index);
            IErc1155Token(numberAddress).mint(msg.sender, tokenId, 1, "");
            emit GachaNumber(msg.sender, _gachaInfo.tokenId, tokenId);
            unchecked { ++i; }
        }
    }

    function randomNumber(bytes32 _seed, uint256 _tokenId, uint32[] memory _ratio, uint32 _ratioSum, string memory _type) private pure returns (uint32 index) {
        uint32 ratio = uint32(uint256(keccak256(abi.encodePacked(_seed, _tokenId, _type))) % _ratioSum) + 1;
        index = 0;
        uint32 ratioSum = 0;
        for (uint8 i = 0; i < _ratio.length;) {
            ratioSum += _ratio[i];
            if (ratio <= ratioSum) {
                break;
            }
            index++;
            unchecked { ++i; }
        }
    }
}