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

import "./IAuctionPlatform.sol";
import "./IAuctionPlatformFactory.sol";
import "./SafeMath.sol";
import "./TransferHelper.sol";
import "./IERC721.sol";


contract MarketplaceRouter{
    
    using SafeMath for uint;
    
    IAuctionPlatformFactory private  factory;
    
    address private  admin;
    
    uint256 public auctionEndMax = 7 days;
    
    mapping(address => uint256) public auctionEndMaxs;
    
    mapping(address => mapping(uint256 => bool)) public auctionPause;
    
    event SetAdmin(address newAdmin);
    
    constructor(IAuctionPlatformFactory _factory,address _admin)public{
        require(_admin != address(0) ,"The contract address is 0x00");
        
        factory = _factory;
        admin = _admin;
    }
    
    modifier onlyAdmin {
        require(msg.sender == admin,"only admin can call");
        _;
    }
    
    uint256 private unlocked = 1;
    
    modifier locked() {
        require(unlocked == 1, 'Distribute: LOCKED');
        unlocked = 0;
        _;
        unlocked = 1;
    }
    
    function setAdmin(address _owner)onlyAdmin external{
        require(_owner != address(0) ,"The contract address is 0x00");
        
        admin = _owner;
        
    }
    
    receive() external payable {
        revert();
    }
    
   
   
    function createPaltform(uint256 _type,address router,uint256 startFee,uint256 succssesFee,address payable _startFeeAddress,address payable _successFeeAddress,uint256 _vervion)external onlyAdmin locked returns(address){
        
      address _address = factory.createAuctionPlatform(_type,router,startFee,succssesFee,_startFeeAddress,_successFeeAddress,_vervion);
      auctionEndMaxs[_address] = auctionEndMax;
      
      require(_address != address(0),"create fail");
      
      return _address;
        
    }
    
    function setRouter(address _platform,address _routerPist) external onlyAdmin {
        
        require(_routerPist != address(0),"router can not be address(0)");
        
        IAuctionPlatform platform = IAuctionPlatform(_platform);
        
        platform.setRouter(_routerPist);
        
    }
    
    function setFee(address _platform,uint256 _type, uint256 fee,address payable feeAddress)external onlyAdmin returns(bool){
        require(feeAddress != address(0) ,"The contract address is 0x00");
        
         IAuctionPlatform platform = IAuctionPlatform(_platform);
         
         return platform.setFee(_type,fee,feeAddress);
        
    }
    
    function setPause(address _platform,bool _pause)external onlyAdmin returns(bool){
        
          IAuctionPlatform platform = IAuctionPlatform(_platform);
          
          return platform.setPause(_pause);
        
    }
    
    function setFactory(IAuctionPlatformFactory _factory)external onlyAdmin returns(bool){
        
        factory = _factory;
        
        return true;
    }
    
    
    function setAuctionPause(address _platform,uint256 _index,bool _pause) external onlyAdmin returns(bool){
        auctionPause[_platform][_index] = _pause;
        return true;
    }
    
    function setAuctionEndMax(address _platform,uint256 _times) external onlyAdmin returns(bool){
        auctionEndMaxs[_platform] = _times;
        return true;
    }
    
    
    function auctionInfo(address _platform,uint256 _index) external view returns(uint256 status,uint256 countDown,uint256 startPrice,uint256 bidAmount,uint256 returnAmount,uint256 heighPrice,uint256 _count,address _winner,uint256 _nftNumber,address _beneficiary){
        
        IAuctionPlatform platform = IAuctionPlatform(_platform);
    
        return platform.auctionInfo(_index,msg.sender);
        
    }
    
    function creationAuction(address _platform, uint256 _NFTid,IERC721 _NFTAddr,uint256 _startPrice,uint256 actionTime,address payContract) public payable locked returns(uint256){
        require(actionTime <= auctionEndMaxs[_platform],"time long!!!" );
        require(_NFTAddr.ownerOf(_NFTid) == msg.sender,"You don't have this NFT");
        require(_NFTAddr.supportsInterface(0x80ac58cd),"does not meet the standards");
        TransferHelper.safeTransferFrom(address(_NFTAddr),msg.sender,_platform,_NFTid);
        
        IAuctionPlatform platform = IAuctionPlatform(_platform);
        
        uint256 _index = platform.creationAuction{value : msg.value}(_NFTid,address(_NFTAddr),_startPrice,actionTime,payContract,msg.sender);
        
        auctionPause[_platform][_index] = true;
        require(_index > 0,"ceate Auction Fail");
        
        return _index;
    }
    
    
    function bid(address _platform,uint256 _index,uint256 price)public payable returns(bool){
        require(auctionPause[_platform][_index],"auction pause");
         IAuctionPlatform platform = IAuctionPlatform(_platform);
         
         (address token) = platform.BidBefore(_index);
         
         
         if(token != address(0)){
             
             require(msg.value == 0,"ERC20 token pay");
        
             TransferHelper.safeTransferFrom(token,msg.sender,_platform,price);
             
         } else {
             
             require(msg.value == price,"price mismatching");
             
         }
         
         bool sucess = platform.bid{value:msg.value}(_index,price,msg.sender);
         require(sucess,"bid fail");
         
         return sucess;
         
    }
    
    
    function withdraw(address _platform,uint256 _index) public returns(bool){
        require(auctionPause[_platform][_index],"auction pause");
        IAuctionPlatform platform = IAuctionPlatform(_platform);
        
        bool sucess = platform.withdraw(_index,msg.sender);
        
        require(sucess,"withdraw fail");
        
        return sucess;
    } 
    
    
    function cancel(address _platform,uint256 _index)external returns(bool){
        require(auctionPause[_platform][_index],"auction pause");
         IAuctionPlatform platform = IAuctionPlatform(_platform);
        
         return platform.cancel(_index,msg.sender);
    }
    
    function getRouter(address _platform)external view returns(address){
         IAuctionPlatform platform = IAuctionPlatform(_platform);
         return platform.getRouter();
    }
    
    
    function getPause(address _platform)external view returns(bool){
         IAuctionPlatform platform = IAuctionPlatform(_platform);
         return platform.getPause();
    }
    
    
    function getFee(address _platform,uint256 _type)external view returns(uint256,address){
         IAuctionPlatform platform = IAuctionPlatform(_platform);
         return platform.getFee(_type);
    }
    
    
    function getFactory()external view returns(address){
        
        return address(factory);
    }
    
    
    function getAdmin()external view returns(address){
        return admin;
    }
    
    
    
}

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


interface IAuctionPlatform {
    
    event _Withdraw(address indexed bider, uint256 amount);
    
    event _Bid(address indexed bider,uint256 price,uint256 _index);
    
    event _Create(address indexed creater,uint256 _index);
    
    event _Cancel(uint256 _index);

    function setRouter(address router) external;
    
    function getRouter()external view returns(address);
    
    function auctionInfo(uint256 _index,address bider) external view returns(uint256 status,uint256 countDown,uint256 startPrice,uint256 bidAmount,uint256 returnAmount,uint256 heighPrice,uint256 _count,address _winner,uint256 _nftNumber,address _beneficiary);
 
    function withdraw(uint256 _index,address payable bider) external returns (bool);
    
    function creationAuction(uint256 _NFTid,address _NFTAddr,uint256 _startPrice,uint256 actionTime,address payContract,address payable _create) external payable returns(uint256 _index);

    function bid(uint256 _index,uint256 price,address bider) external payable returns(bool);
    
    function BidBefore(uint256 _index)external view returns(address);
    
    function cancel(uint256 _index,address creater) external returns(bool);
    
    function getFee(uint256 _type) external view returns(uint256,address);
    
    function setFee(uint256 _type,uint256 _fee,address payable _feeAddress) external returns(bool);

    function getPause() external view returns(bool);
    
    function setPause(bool _pause) external returns(bool);
    
    
}

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


interface IAuctionPlatformFactory{
    
    event Create(address indexed platform);
    
    function createAuctionPlatform(uint256 _type,address router,uint256 startFee,uint256 succssesFee,address payable _startFeeAddress,address payable _successFeeAddress,uint256 _vervion) external returns(address);
    
    function setRouter(address _router) external returns(bool);
    
    function getRouter() external view returns(address);
    
    function setAdmin(address _admin) external returns(bool);
    
    function getAdmin() external view returns(address);
}

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


interface IERC721{
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

}

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

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

import "./SafeMath.sol";
// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    using SafeMath for uint256;
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeTransfer: transfer failed'
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::transferFrom: transferFrom failed'
        );
    }
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
    }
    
    
    function HelpRoyalties(address nftaddress, uint256 tokenId,uint256 _value) external view returns(address,uint256){
        
       (bool success, bytes memory data) =  nftaddress.staticcall(abi.encodeWithSignature("royaltyInfo(uint256,uint256)",tokenId,_value));
       
      if(success && data.length == 64){
          
          (address addr1,uint256 value1)=abi.decode(data, (address,uint256));
          if(addr1 != address(0) && value1 > 0 && value1 <= _value.mul(50).div(100)) {
               
                return( addr1,value1);
          }else if(value1 > _value.mul(50).div(100)){
              
              return (addr1,_value.mul(50).div(100));
              
          }
          
      }
       
      return(address(0),0);
        
       
    }
    
}

{
  "compilationTarget": {
    "Klaytn/CrossRouter.sol": "MarketplaceRouter"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}