// File: contracts/VRFNFTSaleFactory.sol



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

import "@openzeppelin/contracts/proxy/Clones.sol";
import "./interfaces/IVRFNFTSale.sol";

contract VRFNFTSaleCloneFactory {

    event VRFNFTSaleCloneDeployed(address indexed cloneAddress);

    address public referenceVRFNFTSale;
    address public cloner;

    constructor(address _referenceVRFNFTSale) public {
        referenceVRFNFTSale = _referenceVRFNFTSale;
        cloner = msg.sender;
    }

    modifier onlyCloner {
        require(msg.sender == cloner);
        _;
    }

    function changeCloner(address _newCloner) external onlyCloner {
        cloner = _newCloner;
    }

    function newVRFNFTSale(
        address _hausAddress,
        uint256 _startTime,
        uint256 _endTime,
        address _tokenAddress,
        uint256[] memory _tokenIds,
        uint256 _priceWei,
        uint256 _limitPerOrder,
        uint256 _stakingRewardPercentageBasisPoints,
        address _stakingSwapContract,
        address _vrfProvider
    ) external onlyCloner returns (address) {
        // Create new OpenEditionClone
        address newVRFNFTSaleCloneAddress = Clones.clone(referenceVRFNFTSale);
        IVRFNFTSale saleContract = IVRFNFTSale(newVRFNFTSaleCloneAddress);
        saleContract.initialize(
          _hausAddress,
          _startTime,
          _endTime,
          _tokenAddress,
          _tokenIds,
          _priceWei,
          _limitPerOrder,
          _stakingRewardPercentageBasisPoints,
          _stakingSwapContract,
          _vrfProvider,
          msg.sender
        );
        emit VRFNFTSaleCloneDeployed(newVRFNFTSaleCloneAddress);
        return newVRFNFTSaleCloneAddress;
    }

}
// File: @openzeppelin/contracts/proxy/Clones.sol



// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address master) internal returns (address instance) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, master))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create(0, ptr, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `master` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, master))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create2(0, ptr, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, master))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, deployer))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) {
        return predictDeterministicAddress(master, salt, address(this));
    }
}

// File: contracts/interfaces/IVRFNFTSale.sol



// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.6.7;

interface IVRFNFTSale {

  function initialize(
    address _hausAddress,
    uint256 _startTime,
    uint256 _endTime,
    address _tokenAddress,
    uint256[] memory _tokenIds,
    uint256 _priceWei,
    uint256 _limitPerOrder,
    uint256 _stakingRewardPercentageBasisPoints,
    address _stakingSwapContract,
    address _controllerAddress,
    address _vrfProvider
  ) external;
    
  function buy(uint256 amount) external payable;
  function supply() external view returns(uint256);
  function setTokenAddress(address _tokenAddress) external;
  function setTokenIds(uint256[] memory _tokenIds) external;
  function pull() external;
  function initiateRandomDistribution() external;
  function commitRandomDistribution() external;
  function claimAssigned() external;
  function onERC1155Received(address, address, uint256, uint256, bytes calldata) external pure returns(bytes4);
}