// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Arrays.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    
    /**
     * @dev Sort an array of bytes32 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     */
    function sort(
        bytes32[] memory array,
        function(bytes32, bytes32) pure returns (bool) comp
    ) internal pure returns (bytes32[] memory) {
        _quickSort(_begin(array), _end(array), comp);
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of bytes32 in increasing order.
     */
    function sort(bytes32[] memory array) internal pure returns (bytes32[] memory) {
        return sort(array, _defaultComp);
    }

    /**
     * @dev Variant of {sort} that sorts an array of address following a provided comparator function.
     */
    function sort(
        address[] memory array,
        function(address, address) pure returns (bool) comp
    ) internal pure returns (address[] memory) {
        sort(_castToBytes32Array(array), _castToBytes32Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of address in increasing order.
     */
    function sort(address[] memory array) internal pure returns (address[] memory) {
        sort(_castToBytes32Array(array), _defaultComp);
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of uint256 following a provided comparator function.
     */
    function sort(
        uint256[] memory array,
        function(uint256, uint256) pure returns (bool) comp
    ) internal pure returns (uint256[] memory) {
        sort(_castToBytes32Array(array), _castToBytes32Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of uint256 in increasing order.
     */
    function sort(uint256[] memory array) internal pure returns (uint256[] memory) {
        sort(_castToBytes32Array(array), _defaultComp);
        return array;
    }

    /**
     * @dev Performs a quick sort of a segment of memory. The segment sorted starts at `begin` (inclusive), and stops
     * at end (exclusive). Sorting follows the `comp` comparator.
     *
     * Invariant: `begin <= end`. This is the case when initially called by {sort} and is preserved in subcalls.
     *
     * IMPORTANT: Memory locations between `begin` and `end` are not validated/zeroed. This function should
     * be used only if the limits are within a memory array.
     */
    function _quickSort(uint256 begin, uint256 end, function(bytes32, bytes32) pure returns (bool) comp) private pure {
        unchecked {
            if (end - begin < 0x40) return;

            // Use first element as pivot
            bytes32 pivot = _mload(begin);
            // Position where the pivot should be at the end of the loop
            uint256 pos = begin;

            for (uint256 it = begin + 0x20; it < end; it += 0x20) {
                if (comp(_mload(it), pivot)) {
                    // If the value stored at the iterator's position comes before the pivot, we increment the
                    // position of the pivot and move the value there.
                    pos += 0x20;
                    _swap(pos, it);
                }
            }

            _swap(begin, pos); // Swap pivot into place
            _quickSort(begin, pos, comp); // Sort the left side of the pivot
            _quickSort(pos + 0x20, end, comp); // Sort the right side of the pivot
        }
    }

    /**
     * @dev Pointer to the memory location of the first element of `array`.
     */
    function _begin(bytes32[] memory array) private pure returns (uint256 ptr) {
        /// @solidity memory-safe-assembly
        assembly {
            ptr := add(array, 0x20)
        }
    }

    /**
     * @dev Pointer to the memory location of the first memory word (32bytes) after `array`. This is the memory word
     * that comes just after the last element of the array.
     */
    function _end(bytes32[] memory array) private pure returns (uint256 ptr) {
        unchecked {
            return _begin(array) + array.length * 0x20;
        }
    }

    /**
     * @dev Load memory word (as a bytes32) at location `ptr`.
     */
    function _mload(uint256 ptr) private pure returns (bytes32 value) {
        assembly {
            value := mload(ptr)
        }
    }

    /**
     * @dev Swaps the elements memory location `ptr1` and `ptr2`.
     */
    function _swap(uint256 ptr1, uint256 ptr2) private pure {
        assembly {
            let value1 := mload(ptr1)
            let value2 := mload(ptr2)
            mstore(ptr1, value2)
            mstore(ptr2, value1)
        }
    }

    /// @dev Comparator for sorting arrays in increasing order.
    function _defaultComp(bytes32 a, bytes32 b) private pure returns (bool) {
        return a < b;
    }

    /// @dev Helper: low level cast address memory array to uint256 memory array
    function _castToBytes32Array(address[] memory input) private pure returns (bytes32[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast uint256 memory array to uint256 memory array
    function _castToBytes32Array(uint256[] memory input) private pure returns (bytes32[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast address comp function to bytes32 comp function
    function _castToBytes32Comp(
        function(address, address) pure returns (bool) input
    ) private pure returns (function(bytes32, bytes32) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast uint256 comp function to bytes32 comp function
    function _castToBytes32Comp(
        function(uint256, uint256) pure returns (bool) input
    ) private pure returns (function(bytes32, bytes32) pure returns (bool) output) {
        assembly {
            output := input
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

// import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/Address.sol";

library Helper {
    enum Status {
        LISTED,              //0 proposal created by studio
        UPDATED,             //1 proposal updated by studio
        APPROVED_LISTING,    //2 approved for listing by vote from VAB holders(staker)
        APPROVED_FUNDING,    //3 approved for funding by vote from VAB holders(staker)
        REJECTED,            //4 rejected by vote from VAB holders(staker)
        REPLACED             //5 replaced by vote from VAB holders(staker)
    }

    enum TokenType {
        ERC20,
        ERC721,
        ERC1155
    }

    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        require(Address.isContract(token), "C");
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper::safeApprove: approve failed");
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        require(Address.isContract(token), "C");
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "VabbleDAO::safeTransfer: transfer failed");
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        require(Address.isContract(token), "C");
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "VabbleDAO::transferFrom: transferFrom failed");
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "VabbleDAO::safeTransferETH: ETH transfer failed");
    }

    function safeTransferAsset(
        address token,
        address to,
        uint256 value
    ) internal {
        if (token == address(0)) {
            safeTransferETH(to, value);
        } else {
            safeTransfer(token, to, value);
        }
    }

    // function safeTransferNFT(
    //     address _nft,
    //     address _from,
    //     address _to,
    //     TokenType _type,
    //     uint256 _tokenId
    // ) internal {
    //     if (_type == TokenType.ERC721) {
    //         IERC721(_nft).safeTransferFrom(_from, _to, _tokenId);
    //     } else {
    //         IERC1155(_nft).safeTransferFrom(_from, _to, _tokenId, 1, "0x00");
    //     }
    // }

    function isContract(address _address) internal view returns(bool){
        // uint32 size;
        // assembly {
        //     size := extcodesize(_address)
        // }
        // return (size != 0);
        return Address.isContract(_address);
    }

    // function moveToAnotherArray(uint256[] storage array1, uint256[] storage array2, uint256 value) internal {
    //     uint256 index = array1.length;

    //     for(uint256 i = 0; i < array1.length; ++i) {
    //         if(array1[i] == value) {
    //             index = i;
    //         }
    //     }

    //     if (index >= array1.length) return;

    //     array2.push(value);
        
    //     array1[index] = array1[array1.length - 1];
    //     array1.pop();
    // }

    function isTestNet() internal view returns (bool) {
        uint256 id = block.chainid;
        return id == 1337 || id == 80001 || id == 80002 || id == 31337 || id == 84532;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

interface IOwnablee {  
    function auditor() external view returns (address);

    function deployer() external view returns (address);
    
    function replaceAuditor(address _newAuditor) external;

    function transferAuditor(address _newAuditor) external;
    
    function isDepositAsset(address _asset) external view returns (bool);
    
    function getDepositAssetList() external view returns (address[] memory);

    function VAB_WALLET() external view returns (address);
    
    function USDC_TOKEN() external view returns (address);

    function PAYOUT_TOKEN() external view returns (address);

    function addToStudioPool(uint256 _amount) external;

    function withdrawVABFromEdgePool(address _to) external returns (uint256);
}

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

import "../libraries/Helper.sol";

interface IProperty {
    function filmVotePeriod() external view returns (uint256);        // 0
    function agentVotePeriod() external view returns (uint256);       // 1
    function disputeGracePeriod() external view returns (uint256);    // 2
    function propertyVotePeriod() external view returns (uint256);    // 3
    function lockPeriod() external view returns (uint256);            // 4
    function rewardRate() external view returns (uint256);            // 5
    function filmRewardClaimPeriod() external view returns (uint256); // 6
    function maxAllowPeriod() external view returns (uint256);        // 7
    function proposalFeeAmount() external view returns (uint256);     // 8
    function fundFeePercent() external view returns (uint256);        // 9
    function minDepositAmount() external view returns (uint256);      // 10
    function maxDepositAmount() external view returns (uint256);      // 11
    function maxMintFeePercent() external view returns (uint256);     // 12    
    function minVoteCount() external view returns (uint256);          // 13
    function minStakerCountPercent() external view returns (uint256); // 14      
    function availableVABAmount() external view returns (uint256);    // 15     
    function boardVotePeriod() external view returns (uint256);       // 16    
    function boardVoteWeight() external view returns (uint256);       // 17 
    function rewardVotePeriod() external view returns (uint256);      // 18    
    function subscriptionAmount() external view returns (uint256);    // 19
    function boardRewardRate() external view returns (uint256);       // 20      
    // function disputLimitAmount() external view returns (uint256);    

    function DAO_FUND_REWARD() external view returns (address);

    function updateLastVoteTime(address _member) external;

    function getPropertyProposalInfo(uint256 _index, uint256 _flag) external view returns (uint256, uint256, uint256, uint256, address, Helper.Status);
    function getGovProposalInfo(uint256 _index, uint256 _flag) external view returns (uint256, uint256, uint256, address, address, Helper.Status); 

    function updatePropertyProposal(uint256 _index, uint256 _flag, uint256 _approveStatus) external;
    function updateGovProposal(uint256 _index, uint256 _flag, uint256 _approveStatus) external;

    function checkGovWhitelist(uint256 _flag, address _address) external view returns (uint256);
    function checkPropertyWhitelist(uint256 _flag, uint256 _property) external view returns (uint256);
    
    function getAgentProposerStakeAmount(uint256 _index) external view returns (uint256);
}

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

import "../libraries/Helper.sol";

interface IVabbleDAO {
    struct Film {
        string title; // proposal title
        string description; // proposal description
        uint256[] sharePercents; // percents(1% = 1e8) that studio defines to pay reward for each payee
        address[] studioPayees; // payee addresses who studio define to pay reward
        uint256 raiseAmount; // USDC amount(in cash) studio are seeking to raise for the film
        uint256 fundPeriod; // how many days(ex: 20 days) to keep the funding pool open
        uint256 fundType; // Financing Type(None=>0, Token=>1, NFT=>2, NFT & Token=>3)
        uint256 rewardPercent; // reward percent applied to users helped fund film
        uint256 noVote; // if 0 => false, 1 => true
        uint256 enableClaimer; // if 0 => false, 1 => true
        uint256 pCreateTime; // proposal created time(block.timestamp) by studio
        uint256 pApproveTime; // proposal approved time(block.timestamp) by vote
        address studio; // studio address(film owner)
        Helper.Status status; // status of film
    }

    function getFilmFund(uint256 _filmId)
        external
        view
        returns (uint256 raiseAmount_, uint256 fundPeriod_, uint256 fundType_, uint256 rewardPercent_);

    function getFilmStatus(uint256 _filmId) external view returns (Helper.Status status_);

    function getFilmOwner(uint256 _filmId) external view returns (address owner_);

    function getFilmProposalTime(uint256 _filmId) external view returns (uint256 cTime_, uint256 aTime_);

    function approveFilmByVote(uint256 _filmId, uint256 _flag) external;

    function isEnabledClaimer(uint256 _filmId) external view returns (bool enable_);

    function getFilmShare(uint256 _filmId)
        external
        view
        returns (uint256[] memory sharePercents_, address[] memory studioPayees_);

    function getUserFilmListForMigrate(address _user) external view returns (Film[] memory filmList_);

    function withdrawVABFromStudioPool(address _to) external returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @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 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;

    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
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // 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
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "../libraries/Helper.sol";
import "../libraries/Arrays.sol";
import "../interfaces/IVabbleDAO.sol";
import "../interfaces/IProperty.sol";
import "../interfaces/IOwnablee.sol";

contract StakingPool is ReentrancyGuard {
    using Counters for Counters.Counter;
    using Arrays for uint256[];

    event TokenStaked(address indexed staker, uint256 stakeAmount);
    event TokenUnstaked(address indexed unstaker, uint256 unStakeAmount);
    event RewardWithdraw(address indexed staker, uint256 rewardAmount);
    event RewardContinued(address indexed staker, uint256 isCompound, uint256 rewardAmount);
    event AllFundWithdraw(address to, uint256 amount);
    event RewardAdded(uint256 totalRewardAmount, uint256 rewardAmount, address indexed contributor);
    event VABDeposited(address indexed customer, uint256 amount);
    event WithdrawPending(address indexed customer, uint256 amount);
    event PendingWithdrawApproved(address[] customers, uint256[] withdrawAmounts);
    event PendingWithdrawDenied(address[] customers);

    struct Staker {
        address[] keys;
        mapping(address => uint256) indexOf;
    }

    struct Stake {
        uint256 stakeAmount; // staking amount per staker
        uint256 stakeTime;
        uint256 outstandingReward; // after migration is started, this amount will be holded
    }

    struct UserRent {
        uint256 vabAmount; // current VAB amount in DAO
        uint256 withdrawAmount; // pending withdraw amount for a customer
        bool pending; // pending status for withdraw
    }

    struct Props {
        address creator;
        uint256 cTime;
        uint256 period;
        uint256 proposalID;
    }

    address private immutable OWNABLE; // Ownablee contract address
    address private VOTE; // Vote contract address
    address private VABBLE_DAO; // VabbleDAO contract address
    address private DAO_PROPERTY; // Property contract address

    uint256 public totalStakingAmount;
    uint256 public totalRewardAmount;
    uint256 public totalRewardIssuedAmount;
    uint256 public lastfundProposalCreateTime; // funding proposal created time(block.timestamp)
    uint256 public migrationStatus = 0; // 0: not started, 1: started, 2: end
    uint256 public totalMigrationVAB = 0;

    // (user, proposalID) => voteTime need for calculating rewards
    mapping(address => mapping(uint256 => uint256)) private votedTime;
    mapping(address => Stake) public stakeInfo;
    mapping(address => uint256) public receivedRewardAmount; // (staker => received reward amount)
    mapping(address => UserRent) public userRentInfo;
    mapping(address => uint256) public minProposalIndex;

    Counters.Counter public proposalCount; // count of stakers is from No.1

    Staker private stakerMap;
    Props[] private propsList; // need for calculating rewards

    modifier onlyVote() {
        require(msg.sender == VOTE, "not vote");
        _;
    }

    modifier onlyDAO() {
        require(msg.sender == VABBLE_DAO, "not dao");
        _;
    }

    modifier onlyAuditor() {
        require(msg.sender == IOwnablee(OWNABLE).auditor(), "not auditor");
        _;
    }

    modifier onlyDeployer() {
        require(msg.sender == IOwnablee(OWNABLE).deployer(), "not deployer");
        _;
    }

    modifier onlyNormal() {
        require(migrationStatus < 1, "Migration is on going");
        _;
    }

    constructor(address _ownable) {
        require(_ownable != address(0), "zero ownable");
        OWNABLE = _ownable;
    }

    /// @notice Initialize Pool
    function initialize(address _vabbleDAO, address _property, address _vote) external onlyDeployer {
        require(VABBLE_DAO == address(0), "init: initialized");

        require(_vabbleDAO != address(0), "init: zero dao");
        VABBLE_DAO = _vabbleDAO;
        require(_property != address(0), "init: zero property");
        DAO_PROPERTY = _property;
        require(_vote != address(0), "init: zero vote");
        VOTE = _vote;
    }

    /// @notice Add reward token(VAB)
    function addRewardToPool(uint256 _amount) external onlyNormal nonReentrant {
        require(_amount > 0, "aRTP: zero amount");

        Helper.safeTransferFrom(IOwnablee(OWNABLE).PAYOUT_TOKEN(), msg.sender, address(this), _amount);
        totalRewardAmount = totalRewardAmount + _amount;

        emit RewardAdded(totalRewardAmount, _amount, msg.sender);
    }

    /// @notice Staking VAB token by staker
    function stakeVAB(uint256 _amount) external onlyNormal nonReentrant {
        require(_amount > 0, "sVAB: zero amount");

        uint256 minAmount = 10 ** IERC20Metadata(IOwnablee(OWNABLE).PAYOUT_TOKEN()).decimals();
        require(_amount > minAmount, "sVAB: min 1");

        Helper.safeTransferFrom(IOwnablee(OWNABLE).PAYOUT_TOKEN(), msg.sender, address(this), _amount);

        Stake storage si = stakeInfo[msg.sender];
        if (si.stakeAmount == 0 && si.stakeTime == 0) {
            __stakerSet(msg.sender);
        }
        si.outstandingReward += calcRealizedRewards(msg.sender);
        si.stakeAmount += _amount;
        si.stakeTime = block.timestamp;

        totalStakingAmount += _amount;

        __updateMinProposalIndex(msg.sender);

        emit TokenStaked(msg.sender, _amount);
    }

    /// @dev Allows user to unstake tokens after the correct time period has elapsed
    function unstakeVAB(uint256 _amount) external nonReentrant {
        require(msg.sender != address(0), "usVAB: zero staker");

        Stake storage si = stakeInfo[msg.sender];
        uint256 withdrawTime = si.stakeTime + IProperty(DAO_PROPERTY).lockPeriod();
        require(si.stakeAmount >= _amount, "usVAB: insufficient");
        require(migrationStatus > 0 || block.timestamp > withdrawTime, "usVAB: lock");

        // first, withdraw reward
        uint256 rewardAmount = calcRewardAmount(msg.sender);
        if (totalRewardAmount >= rewardAmount && rewardAmount > 0) {
            __withdrawReward(rewardAmount);
        }

        // Next, unstake
        Helper.safeTransfer(IOwnablee(OWNABLE).PAYOUT_TOKEN(), msg.sender, _amount);

        si.stakeTime = block.timestamp;
        si.stakeAmount -= _amount;
        totalStakingAmount -= _amount;

        if (si.stakeAmount == 0) {
            delete stakeInfo[msg.sender];

            // remove staker from list
            __stakerRemove(msg.sender);
        }

        emit TokenUnstaked(msg.sender, _amount);
    }

    /// @notice Withdraw reward.  isCompound=1 => compound reward, isCompound=0 => withdraw
    function withdrawReward(uint256 _isCompound) external nonReentrant {
        require(_isCompound == 0 || _isCompound == 1, "wR: compound");
        require(stakeInfo[msg.sender].stakeAmount > 0, "wR: zero amount");

        uint256 withdrawTime = stakeInfo[msg.sender].stakeTime + IProperty(DAO_PROPERTY).lockPeriod();
        require(migrationStatus > 0 || block.timestamp > withdrawTime, "wR: lock");

        if (migrationStatus > 0) {
            require(_isCompound == 0, "migration is on going");
        }

        uint256 rewardAmount = calcRewardAmount(msg.sender);
        require(rewardAmount > 0, "wR: zero reward");

        if (_isCompound == 1) {
            Stake storage si = stakeInfo[msg.sender];
            si.stakeAmount = si.stakeAmount + rewardAmount;
            si.stakeTime = block.timestamp;
            si.outstandingReward = 0;

            totalStakingAmount += rewardAmount;

            __updateMinProposalIndex(msg.sender);

            emit RewardContinued(msg.sender, _isCompound, rewardAmount);
        } else {
            require(totalRewardAmount >= rewardAmount, "wR: insufficient total");

            __withdrawReward(rewardAmount);
        }
    }

    /// @dev Transfer reward amount
    function __withdrawReward(uint256 _amount) private {
        Helper.safeTransfer(IOwnablee(OWNABLE).PAYOUT_TOKEN(), msg.sender, _amount);

        totalRewardAmount -= _amount;
        receivedRewardAmount[msg.sender] += _amount;
        totalRewardIssuedAmount += _amount;

        stakeInfo[msg.sender].stakeTime = block.timestamp;
        stakeInfo[msg.sender].outstandingReward = 0;

        emit RewardWithdraw(msg.sender, _amount);

        // update minProposalIndex
        __updateMinProposalIndex(msg.sender);
    }

    /// @notice Calculate reward amount with previous reward
    function calcRewardAmount(address _user) public view returns (uint256) {
        Stake memory si = stakeInfo[_user];

        if (si.stakeAmount == 0) return 0;

        if (migrationStatus > 0) {
            // if migration is started
            return si.outstandingReward; // just return pre-calculated amount
        } else {
            return si.outstandingReward + calcRealizedRewards(_user);
        }
    }

    function __calcProposalTimeIntervals(address _user) public view returns (uint256[] memory times_) {
        uint256 pLength = propsList.length;
        Props memory pData;
        uint256 stakeTime = stakeInfo[_user].stakeTime;
        uint256 end = block.timestamp;

        // find all start/end proposal whose end >= stakeTime
        uint256 count = 0;
        uint256 minIndex = minProposalIndex[_user];
        for (uint256 i = minIndex; i < pLength; ++i) {
            if (propsList[i].cTime + propsList[i].period >= stakeInfo[_user].stakeTime) {
                count++;
            }
        }

        times_ = new uint256[](2 * count + 2);

        times_[0] = stakeTime;

        // find all start/end proposal whose end >= stakeTime
        count = 0;

        for (uint256 i = minIndex; i < pLength; ++i) {
            pData = propsList[i];

            if (pData.cTime + pData.period >= stakeTime) {
                times_[2 * count + 1] = pData.cTime;
                times_[2 * count + 2] = pData.cTime + pData.period;

                if (times_[2 * count + 2] > end) {
                    times_[2 * count + 2] = end;
                }
                count++;
            }
        }
        times_[2 * count + 1] = end;

        // sort times
        times_.sort();
    }

    // function __calcProposalTimeIntervalsTest(address _user) public view returns (uint256[] memory times_, uint256
    // count_) {
    //     uint256 pLength = propsList.length;
    //     Props memory pData;
    //     uint256 stakeTime = stakeInfo[_user].stakeTime;
    //     uint256 end = block.timestamp;

    //     // find all start/end proposal whose end >= stakeTime
    //     uint256 count = 0;
    //     uint256 minIndex = minProposalIndex[_user];
    //     for(uint256 i = minIndex; i < pLength; ++i) {
    //         if (propsList[i].cTime + propsList[i].period >= stakeInfo[_user].stakeTime) {
    //             count++;
    //         }
    //     }

    //     times_ = new uint[](2 * count + 2);

    //     times_[0] = stakeTime;

    //     // find all start/end proposal whose end >= stakeTime
    //     count = 0;

    //     for(uint256 i = minIndex; i < pLength; ++i) {
    //         pData = propsList[i];

    //         if (pData.cTime + pData.period >= stakeTime) {
    //             times_[2 * count + 1] = pData.cTime;
    //             times_[2 * count + 2] = pData.cTime + pData.period;
    //             count++;
    //         }
    //     }
    //     times_[2 * count + 1] = end;

    //     count_ = count;
    // }

    function __getProposalVoteCount(
        address _user,
        uint256 minIndex,
        uint256 _start,
        uint256 _end
    )
        public
        view
        returns (uint256, uint256, uint256)
    {
        uint256 pCount = 0;
        uint256 vCount = 0;
        uint256 pendingVoteCount = 0;
        Props memory pData;
        uint256 pLength = propsList.length;

        for (uint256 j = minIndex; j < pLength; ++j) {
            pData = propsList[j];

            if (pData.cTime <= _start && _end <= pData.cTime + pData.period) {
                pCount++;
                if (pData.creator == _user || votedTime[_user][pData.proposalID] > 0) {
                    if (_start >= stakeInfo[_user].stakeTime) {
                        // interval is after stake
                        vCount += 1;
                    } else {
                        // interval is before stake
                        if (pData.creator == _user || votedTime[_user][pData.proposalID] <= stakeInfo[_user].stakeTime)
                        {
                            // already vote in previous period
                            // ignore
                        } else {
                            vCount += 1;
                        }
                    }
                } else {
                    if (block.timestamp <= pData.cTime + pData.period) {
                        // vote period is not over
                        pendingVoteCount += 1;
                    }
                }
            }
        }

        return (pCount, vCount, pendingVoteCount);
    }

    function __updateMinProposalIndex(address _user) private {
        uint256 pLength = propsList.length;
        uint256 minIndex = minProposalIndex[_user];
        for (uint256 i = minIndex; i < pLength; ++i) {
            if (propsList[i].cTime + propsList[i].period >= stakeInfo[_user].stakeTime) {
                minProposalIndex[_user] = i;
                break;
            }
        }
    }

    /// @notice Calculate realized rewards
    function calcRealizedRewards(address _user) public view returns (uint256) {
        uint256 realizeReward = 0;

        uint256[] memory times = __calcProposalTimeIntervals(_user);

        uint256 minIndex = minProposalIndex[_user];

        uint256 intervalCount = times.length - 1;
        uint256 start;
        uint256 end;
        uint256 amount = 0;
        for (uint256 i = 0; i < intervalCount; ++i) {
            // determine proposal start and end time
            start = times[i];
            end = times[i + 1];

            // count all proposals which contains interval [t(i), t(i + 1))]
            // and also count vote proposals which contains  interval [t(i), t(i + 1))]
            (uint256 pCount, uint256 vCount,) = __getProposalVoteCount(_user, minIndex, start, end);
            amount = __calcRewards(_user, start, end);

            if (pCount > 0) {
                uint256 countRate = (vCount * 1e4) / pCount;
                amount = (amount * countRate) / 1e4;
            }

            realizeReward += amount;
        }

        return realizeReward;
    }

    function calcPendingRewards(address _user) public view returns (uint256) {
        uint256 pendingReward = 0;

        uint256[] memory times = __calcProposalTimeIntervals(_user);

        uint256 minIndex = minProposalIndex[_user];

        uint256 intervalCount = times.length - 1;
        uint256 start;
        uint256 end;
        uint256 amount = 0;
        for (uint256 i = 0; i < intervalCount; ++i) {
            // determine proposal start and end time
            start = times[i];
            end = times[i + 1];

            // count all proposals which contains interval [t(i), t(i + 1))]
            // and also count vote proposals which contains  interval [t(i), t(i + 1))]
            (uint256 pCount,, uint256 pendingVoteCount) = __getProposalVoteCount(_user, minIndex, start, end);
            amount = __calcRewards(_user, start, end);

            if (pCount > 0) {
                uint256 countRate = (pendingVoteCount * 1e4) / pCount;
                amount = (amount * countRate) / 1e4;
            } else {
                amount = 0;
            }

            pendingReward += amount;
        }

        return pendingReward;
    }

    function __calcRewards(address _user, uint256 startTime, uint256 endTime) private view returns (uint256 amount_) {
        Stake memory si = stakeInfo[_user];
        if (si.stakeAmount == 0) return 0;
        if (startTime == 0) return 0;

        uint256 rewardPercent = __rewardPercent(si.stakeAmount); // 0.0125*1e8 = 0.0125%

        // Get time with accuracy(10**4) from after lockPeriod
        uint256 period = ((endTime - startTime) * 1e4) / 1 days;
        amount_ = (totalRewardAmount * rewardPercent * period) / 1e10 / 1e4;

        // If user is film board member, more rewards(25%)
        if (IProperty(DAO_PROPERTY).checkGovWhitelist(2, _user) == 2) {
            amount_ += (amount_ * IProperty(DAO_PROPERTY).boardRewardRate()) / 1e10;
        }
    }

    // 500 * 1e10 / 1000 = 50*1e8 = 50%
    // 0.025*1e8 * 50*1e8 / 1e10 = 0.0125*1e8 = 0.0125%
    function __rewardPercent(uint256 _stakingAmount) private view returns (uint256 percent_) {
        uint256 poolPercent = (_stakingAmount * 1e10) / totalStakingAmount;
        percent_ = (IProperty(DAO_PROPERTY).rewardRate() * poolPercent) / 1e10;
    }

    /// @notice Calculate APR(Annual Percentage Rate) for staking/pending rewards
    function calculateAPR(
        uint256 _period, // ex: 2 days / 32 days / 365 days
        uint256 _stakeAmount, // ex: 100 VAB
        uint256 _proposalCount,
        uint256 _voteCount,
        bool isBoardMember // filmboard member or not
    )
        external
        view
        returns (uint256 amount_)
    {
        require(_period > 0, "apr: zero period");
        require(_stakeAmount > 0, "apr: zero staker");
        require(_proposalCount >= _voteCount, "apr: bad vote count");

        // Annual rate = daily rate x period(ex: 365)
        uint256 rewardPercent = __rewardPercent(_stakeAmount); // 0.0125*1e8 = 0.0125%
        uint256 stakingRewards = (totalRewardAmount * rewardPercent * _period) / 1e10;

        // If customer is film board member, more rewards(25%)
        if (isBoardMember) {
            stakingRewards += (stakingRewards * IProperty(DAO_PROPERTY).boardRewardRate()) / 1e10;
        }

        // if no proposal then full rewards, if no vote for 5 proposals then no rewards, if 3 votes for 5 proposals then
        // rewards*3/5
        uint256 pendingRewards;
        if (_proposalCount > 0) {
            if (_voteCount == 0) {
                pendingRewards = 0;
            } else {
                uint256 countVal = (_voteCount * 1e4) / _proposalCount;
                pendingRewards = (stakingRewards * countVal) / 1e4;
            }
        }

        amount_ = stakingRewards + pendingRewards;
    }

    // =================== Customer deposit/withdraw VAB START =================
    /// @notice Deposit VAB token from customer for renting the films
    function depositVAB(uint256 _amount) external onlyNormal nonReentrant {
        _depositVAB(msg.sender, _amount);
    }

    // Main implementation with subscriber parameter
    function depositVABTo(address subscriber, uint256 _amount) external onlyNormal nonReentrant {
        _depositVAB(subscriber, _amount);
    }

    // function to handle the core deposit logic
    function _depositVAB(address subscriber, uint256 _amount) private {
        require(subscriber != address(0), "dVAB: zero address");
        require(_amount > 0, "dVAB: zero amount");

        Helper.safeTransferFrom(IOwnablee(OWNABLE).PAYOUT_TOKEN(), msg.sender, address(this), _amount);
        userRentInfo[subscriber].vabAmount += _amount;

        emit VABDeposited(subscriber, _amount);
    }

    /// @notice Pending Withdraw VAB token by customer
    function pendingWithdraw(uint256 _amount) external nonReentrant {
        require(msg.sender != address(0), "pW: zero address");
        require(_amount > 0, "pW: zero VAB");
        require(!userRentInfo[msg.sender].pending, "pW: pending");

        uint256 cAmount = userRentInfo[msg.sender].vabAmount;
        uint256 wAmount = userRentInfo[msg.sender].withdrawAmount;
        require(_amount <= cAmount - wAmount, "pW: insufficient VAB");

        userRentInfo[msg.sender].withdrawAmount += _amount;
        userRentInfo[msg.sender].pending = true;

        emit WithdrawPending(msg.sender, _amount);
    }

    /// @notice Approve pending-withdraw of given customers by Auditor
    function approvePendingWithdraw(address[] calldata _customers) external onlyAuditor nonReentrant {
        require(_customers.length > 0 && _customers.length < 1000, "aPW: No customer");

        uint256[] memory withdrawAmounts = new uint256[](_customers.length);
        // Transfer withdrawable amount to _customers
        uint256 customerLength = _customers.length;
        for (uint256 i = 0; i < customerLength; ++i) {
            withdrawAmounts[i] = __transferVABWithdraw(_customers[i]);
        }

        emit PendingWithdrawApproved(_customers, withdrawAmounts);
    }

    /// @dev Transfer VAB token to user's withdraw request
    function __transferVABWithdraw(address _to) private returns (uint256) {
        uint256 payAmount = userRentInfo[_to].withdrawAmount;
        require(payAmount > 0, "aW: zero withdraw");
        require(payAmount <= userRentInfo[_to].vabAmount, "aW: insufficuent");
        require(userRentInfo[_to].pending, "aW: no pending");

        Helper.safeTransfer(IOwnablee(OWNABLE).PAYOUT_TOKEN(), _to, payAmount);

        userRentInfo[_to].vabAmount -= payAmount;
        userRentInfo[_to].withdrawAmount = 0;
        userRentInfo[_to].pending = false;

        return payAmount;
    }

    function checkApprovePendingWithdraw(address[] calldata _customers) external view returns (bool) {
        address _to;
        uint256 payAmount;
        uint256 sum = 0;
        uint256 customerLength = _customers.length;
        for (uint256 i = 0; i < customerLength; ++i) {
            _to = _customers[i];
            payAmount = userRentInfo[_to].withdrawAmount;
            if (payAmount == 0) {
                return false;
            }

            if (payAmount > userRentInfo[_to].vabAmount) {
                return false;
            }

            if (!userRentInfo[_to].pending) {
                return false;
            }

            sum += payAmount;
        }

        address vabToken = IOwnablee(OWNABLE).PAYOUT_TOKEN();

        if (IERC20(vabToken).balanceOf(address(this)) < sum) {
            return false;
        }

        return true;
    }

    /// @notice Deny pending-withdraw of given customers by Auditor
    function denyPendingWithdraw(address[] calldata _customers) external onlyAuditor nonReentrant {
        require(_customers.length > 0 && _customers.length < 1000, "denyW: bad customers");

        // Release withdrawable amount for _customers
        uint256 customerLength = _customers.length;
        for (uint256 i = 0; i < customerLength; ++i) {
            require(userRentInfo[_customers[i]].withdrawAmount > 0, "denyW: zero withdraw");
            require(userRentInfo[_customers[i]].pending, "denyW: no pending");

            userRentInfo[_customers[i]].withdrawAmount = 0;
            userRentInfo[_customers[i]].pending = false;
        }

        emit PendingWithdrawDenied(_customers);
    }

    function checkDenyPendingWithDraw(address[] calldata _customers) external view returns (bool) {
        uint256 customerLength = _customers.length;
        for (uint256 i = 0; i < customerLength; ++i) {
            if (userRentInfo[_customers[i]].withdrawAmount == 0) {
                return false;
            }

            if (!userRentInfo[_customers[i]].pending) {
                return false;
            }
        }
        return true;
    }

    /// @notice onlyDAO transfer VAB token to user
    function sendVAB(
        address[] calldata _users,
        address _to,
        uint256[] calldata _amounts
    )
        external
        onlyDAO
        returns (uint256)
    {
        require(_users.length == _amounts.length && _users.length < 1000, "sendVAB: bad array");
        uint256 sum;
        uint256 userLength = _users.length;
        for (uint256 i = 0; i < userLength; ++i) {
            require(userRentInfo[_users[i]].vabAmount >= _amounts[i], "sendVAB: insufficient");

            userRentInfo[_users[i]].vabAmount -= _amounts[i];
            sum += _amounts[i];
        }

        Helper.safeTransfer(IOwnablee(OWNABLE).PAYOUT_TOKEN(), _to, sum);

        return sum;
    }

    function checkAllocateToPool(address[] calldata _users, uint256[] calldata _amounts) external view returns (bool) {
        uint256 sum;
        uint256 userLength = _users.length;
        for (uint256 i = 0; i < userLength; ++i) {
            if (userRentInfo[_users[i]].vabAmount < _amounts[i]) {
                return false;
            }

            sum += _amounts[i];
        }

        address vabToken = IOwnablee(OWNABLE).PAYOUT_TOKEN();

        if (IERC20(vabToken).balanceOf(address(this)) < sum) {
            return false;
        }

        return true;
    }

    /// @notice Transfer DAO all fund to V2
    // After call this function, users should be available to withdraw his funds deposited
    function withdrawAllFund() external onlyAuditor nonReentrant {
        address to = IProperty(DAO_PROPERTY).DAO_FUND_REWARD();
        require(to != address(0), "wAF: zero address");
        require(migrationStatus == 1, "Migration is not on going");

        address vabToken = IOwnablee(OWNABLE).PAYOUT_TOKEN();

        uint256 sumAmount;
        // Transfer rewards of Staking Pool
        if (IERC20(vabToken).balanceOf(address(this)) >= totalMigrationVAB && totalMigrationVAB > 0) {
            Helper.safeTransfer(vabToken, to, totalMigrationVAB);
            sumAmount += sumAmount + totalMigrationVAB;
            totalRewardAmount = totalRewardAmount - totalMigrationVAB;
            totalMigrationVAB = 0;
        }

        // Transfer VAB of Edge Pool(Ownable)
        sumAmount += IOwnablee(OWNABLE).withdrawVABFromEdgePool(to);

        // Transfer VAB of Studio Pool(VabbleDAO)
        sumAmount += IVabbleDAO(VABBLE_DAO).withdrawVABFromStudioPool(to);

        migrationStatus = 2; // migration is end

        emit AllFundWithdraw(to, sumAmount);
    }

    function calcMigrationVAB() external onlyNormal nonReentrant {
        require(msg.sender == DAO_PROPERTY, "not Property");

        uint256 amount = 0;
        uint256 totalAmount = 0; // sum of each staker's rewards

        // calculate the total amount of reward
        for (uint256 i = 0; i < stakerCount(); ++i) {
            amount = calcRewardAmount(stakerMap.keys[i]);
            stakeInfo[stakerMap.keys[i]].outstandingReward = amount;
            totalAmount = totalAmount + amount;
        }

        if (totalRewardAmount >= totalAmount) {
            totalMigrationVAB = totalRewardAmount - totalAmount;
        }

        migrationStatus = 1;
    }

    /// @notice Add voted time for a staker when vote
    function addVotedData(address _user, uint256 _time, uint256 _proposalID) external onlyVote {
        votedTime[_user][_proposalID] = _time;
    }

    /// @notice Update lastfundProposalCreateTime for only fund film proposal
    function updateLastfundProposalCreateTime(uint256 _time) external onlyDAO {
        lastfundProposalCreateTime = _time;
    }

    /// @notice Add proposal data to array for calculating rewards
    function addProposalData(address _creator, uint256 _cTime, uint256 _period) external returns (uint256) {
        require(msg.sender == VABBLE_DAO || msg.sender == DAO_PROPERTY, "not dao/property");

        proposalCount.increment();
        uint256 proposalID = proposalCount.current();
        propsList.push(Props(_creator, _cTime, _period, proposalID));

        return proposalID;
    }

    /// @notice Get staking amount for a staker
    function getStakeAmount(address _user) external view returns (uint256 amount_) {
        amount_ = stakeInfo[_user].stakeAmount;
    }

    /// @notice Get user rent VAB amount
    function getRentVABAmount(address _user) external view returns (uint256 amount_) {
        amount_ = userRentInfo[_user].vabAmount;
    }

    /// @notice Get limit staker count for voting
    function getLimitCount() external view returns (uint256 count_) {
        uint256 limitPercent = IProperty(DAO_PROPERTY).minStakerCountPercent();
        uint256 minVoteCount = IProperty(DAO_PROPERTY).minVoteCount();

        uint256 limitStakerCount = (stakerCount() * limitPercent * 1e4) / 1e10;
        if (limitStakerCount <= minVoteCount * 1e4) {
            count_ = minVoteCount;
        } else {
            // limitStakerCount=12500 => count=1
            count_ = limitStakerCount / 1e4;
        }
    }

    /// @notice Get withdrawTime for a staker
    function getWithdrawableTime(address _user) external view returns (uint256 time_) {
        time_ = stakeInfo[_user].stakeTime + IProperty(DAO_PROPERTY).lockPeriod();
    }

    //? View / Pure functions
    function getOwnableAddress() public view returns (address) {
        return OWNABLE;
    }

    function getVoteAddress() public view returns (address) {
        return VOTE;
    }

    function getVabbleDaoAddress() public view returns (address) {
        return VABBLE_DAO;
    }

    function getPropertyAddress() public view returns (address) {
        return DAO_PROPERTY;
    }

    function getStakerList() external view returns (address[] memory) {
        return stakerMap.keys;
    }

    function stakerCount() public view returns (uint256) {
        return stakerMap.keys.length;
    }

    function __stakerSet(address key) private {
        if (stakerMap.indexOf[key] > 0) return;

        stakerMap.indexOf[key] = stakerMap.keys.length + 1;
        stakerMap.keys.push(key);
    }

    function __stakerRemove(address key) private {
        if (stakerMap.indexOf[key] == 0) return;

        uint256 index = stakerMap.indexOf[key];
        address lastKey = stakerMap.keys[stakerMap.keys.length - 1];

        stakerMap.indexOf[lastKey] = index;
        delete stakerMap.indexOf[key];

        stakerMap.keys[index - 1] = lastKey;
        stakerMap.keys.pop();
    }
}

{
  "compilationTarget": {
    "contracts/dao/StakingPool.sol": "StakingPool"
  },
  "evmVersion": "cancun",
  "libraries": {
    "contracts/libraries/DAOOperations.sol:DAOOperations": "0xdaf27e7ad131c8d2b3e7d3f25342a201e11c88a4"
  },
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@ensdomains/=node_modules/@ensdomains/",
    ":@ethereum-waffle/=node_modules/@ethereum-waffle/",
    ":@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    ":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":eth-gas-reporter/=node_modules/eth-gas-reporter/",
    ":forge-std/=lib/forge-std/src/",
    ":foundry-devops/=lib/foundry-devops/",
    ":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    ":hardhat-deploy/=node_modules/hardhat-deploy/",
    ":hardhat/=node_modules/hardhat/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ]
}