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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

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

import "./FanspaySubscription.sol";
import "./FanspayDeferredCharge.sol";

contract Fanspay is FanspaySubscription, FanspayDeferredCharge {
    event TopUp(uint amount, address from, bytes payload);

    fallback() external payable {
        (bool sent,) = payable(owner()).call{value : msg.value}("");
        require(sent, "Failed to send Ether");

        emit TopUp(msg.value, msg.sender, msg.data);
    }

    receive() external payable {
        (bool sent,) = payable(owner()).call{value : msg.value}("");
        require(sent, "Failed to send Ether");
    }
}

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

import "./FanspayFee.sol";

contract FanspayCharge is FanspayFee {
    event ChargeEvent(uint amount, uint fee, string payload);

    function charge(string memory _payload, Share[] memory _shareList, address _tokenAddress) public {
        (uint fanspayFee, uint amount) = _getShareListSums(_shareList);

        _checkFanspayFee(fanspayFee, amount);

        _checkAllowance(_msgSender(), amount, _tokenAddress);
        _checkBalance(_msgSender(), amount, _tokenAddress);
        _transferToken(_msgSender(), _shareList, _tokenAddress);
        emit ChargeEvent(amount, fanspayFee, _payload);
    }

    function _fanspayFeeIsCorrect(uint _fanspayFee, uint _amount) internal view returns (bool) {
        uint fanspayFee = _amount * fee() / 1000;
        if (fanspayFee <= 0) {
            fanspayFee = 1;
        }
        return fanspayFee <= _fanspayFee;
    }

    function _checkFanspayFee(uint _fanspayFee, uint _amount) internal view {
        require(
            _fanspayFeeIsCorrect(_fanspayFee, _amount),
            "Fee is not correct"
        );
    }
}

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

import "./FanspayCharge.sol";

contract FanspayDeferredCharge is FanspayCharge {
    struct DeferredCharge {
        uint chargeTime;
        address payer;
        Share[] shareList;
        string status; // waiting | paid | canceled | failed
        address tokenAddress;
    }

    mapping(string => DeferredCharge) public deferredCharges;

    event DeferredChargeEvent(string id);

    function deferCharge(uint _deferredFor, string memory _id, Share[] memory _shareList, address _tokenAddress) public {
        _checkAvailableDeferredCharge(_id);
        DeferredCharge storage charge = deferredCharges[_id];

        (uint fanspayFee, uint amount) = _getShareListSums(_shareList);

        _checkFanspayFee(fanspayFee, amount);
        _checkAllowance(_msgSender(), amount, _tokenAddress);

        charge.chargeTime = block.timestamp + _deferredFor;
        charge.payer = _msgSender();
        charge.status = "waiting";
        charge.tokenAddress = _tokenAddress;

        for (uint i = 0; i < _shareList.length; i++) {
            charge.shareList.push(_shareList[i]);
        }


        emit DeferredChargeEvent(_id);
    }

    function cancelDeferredCharge(string memory _id) public {
        _checkDeferredChargeStatus(_id, "waiting");

        deferredCharges[_id].status = "canceled";
        emit DeferredChargeEvent(_id);
    }

    function getDeferredCharge(string memory _id) public view returns (DeferredCharge memory) {
        _checkDeferredCharge(_id);

        return deferredCharges[_id];
    }

    function chargeDeferredCharge(string memory _id) public {
        _checkDeferredChargeStatus(_id, "waiting");
        _checkDeferredChargeTime(_id);

        DeferredCharge storage charge = deferredCharges[_id];
        (uint fanspayFee, uint amount) = _getShareListSums(charge.shareList);

        if (_isEnoughAllowanceAndBalance(charge.payer, amount, charge.tokenAddress)) {
            _transferToken(charge.payer, charge.shareList, charge.tokenAddress);
            charge.status = "paid";

            emit DeferredChargeEvent(_id);
            emit ChargeEvent(amount, fanspayFee, _id);
            return;
        }

        charge.status = "failed";
        emit DeferredChargeEvent(_id);
    }

    function chargeDeferredCharges(string[] memory _ids) public {
        for (uint i = 0; i < _ids.length; i++) {
            chargeDeferredCharge(_ids[i]);
        }
    }

    function _checkAvailableDeferredCharge(string memory _id) view internal {
        require(
            deferredCharges[_id].chargeTime == 0,
            "Deferred charge already exist"
        );
    }

    function _checkDeferredCharge(string memory _id) view internal {
        require(
            deferredCharges[_id].chargeTime != 0,
            "Deferred charge does not exist"
        );
    }

    function _checkDeferredChargeStatus(string memory _id, string memory _status) view internal {
        _checkDeferredCharge(_id);

        require(
            keccak256(abi.encodePacked(deferredCharges[_id].status)) == keccak256(abi.encodePacked(_status)),
            string(abi.encodePacked("Deferred charge status is not ", _status))
        );
    }

    function _checkDeferredChargeTime(string memory _id) view internal {
        _checkDeferredCharge(_id);
        require(
            deferredCharges[_id].chargeTime <= block.timestamp,
            "Deferred charge time is not reached"
        );
    }
}

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

import "./FanspayTokens.sol";

contract FanspayFee is FanspayTokens {
    uint private _fee;

    event FeeChangedEvent(uint previousFee, uint newFee);

    constructor() {
        _changeFee(10);
    }

    function fee() public view virtual returns (uint) {
        return _fee;
    }

    function changeFee(uint _amount) public onlyOwner {
        _changeFee(_amount);
    }

    function _changeFee(uint newFee) internal virtual {
        uint oldFee = _fee;
        _fee = newFee;
        emit FeeChangedEvent(oldFee, newFee);
    }

}

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract FanspayManager is Ownable {
    address private _manager;

    event ManagerChangedEvent(address previousManager, address newManager);

    constructor() {
        _changeManager(_msgSender());
    }

    function getManager() public view virtual returns (address) {
        return _manager;
    }

    function changeManager(address manager) public onlyOwner {
        _changeManager(manager);
    }

    function _changeManager(address newManager) internal virtual {
        address oldManager = _manager;
        _manager = newManager;
        emit ManagerChangedEvent(oldManager, newManager);
    }

    function _isManager(address manager) internal view returns (bool) {
        return _manager == manager;
    }
}

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract FanspayShare is Ownable {
    struct Share {
        uint amount;
        address receiver;
    }

    constructor() {}

    function _getShareListSums(Share[] memory _shareList) internal view returns (uint, uint) {
        uint fanspayFee;
        uint sum;

        for (uint i = 0; i < _shareList.length; i++) {
            sum += _shareList[i].amount;
            if (_shareList[i].receiver == owner()) {
                fanspayFee += _shareList[i].amount;
            }
        }

        return (fanspayFee, sum);
    }
}

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

import "./FanspayCharge.sol";
import "./FanspayManager.sol";

contract FanspaySubscription is FanspayCharge, FanspayManager {
    struct Subscription {
        uint chargeTime;
        uint interval;
        address payer;
        Share[] shareList;
        string status; // waiting | active | canceled | failed
        address tokenAddress;
    }

    mapping(string => Subscription) public subscriptions;

    event SubscriptionEvent(string id);

    function subscribe(uint _deferredFor, uint _interval, string memory _id, Share[] memory _shareList, address _tokenAddress) public {
        _checkAvailableSubscription(_id);
        Subscription storage subscription = subscriptions[_id];

        (uint fanspayFee, uint amount) = _getShareListSums(_shareList);

        _checkFanspayFee(fanspayFee, amount);
        _checkAllowance(_msgSender(), amount, _tokenAddress);

        if (_deferredFor == 0) {
            _checkBalance(_msgSender(), amount, _tokenAddress);

            _transferToken(_msgSender(), _shareList, _tokenAddress);
            subscription.chargeTime = block.timestamp + _interval;
            subscription.status = "active";
            emit ChargeEvent(amount, fanspayFee, _id);
        } else {
            subscription.chargeTime = block.timestamp + _deferredFor;
            subscription.status = "waiting";
        }

        subscription.interval = _interval;
        subscription.payer = _msgSender();
        subscription.tokenAddress = _tokenAddress;

        for (uint i = 0; i < _shareList.length; i++) {
            subscription.shareList.push(_shareList[i]);
        }

        emit SubscriptionEvent(_id);
    }

    function cancelSubscription(string memory _id) public {
        _checkSubscriptionLive(_id);
        _checkSubscriptionPayer(_id, _msgSender());

        subscriptions[_id].status = "canceled";
        emit SubscriptionEvent(_id);
    }

    function cancelSubscriptions(string[] memory _ids) public {
        for (uint i = 0; i < _ids.length; i++) {
            if (_isSubscriptionLive(_ids[i]) && (_isSubscriptionPayer(_ids[i], _msgSender()) || _isManager(_msgSender()))) {
                subscriptions[_ids[i]].status = "canceled";
                emit SubscriptionEvent(_ids[i]);
            }
        }
    }

    function getSubscription(string memory _id) public view returns (Subscription memory) {
        _checkSubscription(_id);

        return subscriptions[_id];
    }

    function chargeSubscription(string memory _id) public {
        _checkSubscriptionLive(_id);
        _checkSubscriptionTime(_id);

        _chargeSubscription(_id);
    }

    function chargeSubscriptions(string[] memory _ids) public {
        for (uint i = 0; i < _ids.length; i++) {
            if (_isSubscriptionLive(_ids[i]) && _isSubscriptionChargeTime(_ids[i])) {
                _chargeSubscription(_ids[i]);
            }
        }
    }

    function _chargeSubscription(string memory _id) internal {
        Subscription storage subscription = subscriptions[_id];
        (uint fanspayFee, uint amount) = _getShareListSums(subscription.shareList);

        if (_isEnoughAllowanceAndBalance(subscription.payer, amount, subscription.tokenAddress)) {
            _transferToken(subscription.payer, subscription.shareList, subscription.tokenAddress);

            subscription.chargeTime += subscription.interval;
            if (_isSubscriptionStatus(_id, "waiting")) {
                subscription.status = "active";
            }
            emit ChargeEvent(amount, fanspayFee, _id);
        } else {
            subscription.status = "failed";
        }

        emit SubscriptionEvent(_id);
    }


    function _checkSubscription(string memory _id) internal view {
        require(
            subscriptions[_id].chargeTime != 0,
            "Subscription not exist"
        );
    }

    function _checkSubscriptionPayer(string memory _id, address payer) internal view {
        _checkSubscription(_id);

        require(
            _isSubscriptionPayer(_id, payer),
            "Subscription payer is not correct"
        );
    }

    function _isSubscriptionPayer(string memory _id, address payer) internal view returns (bool) {
        return subscriptions[_id].payer == payer;
    }

    function _checkAvailableSubscription(string memory _id) view internal {
        require(
            subscriptions[_id].chargeTime == 0,
            "Subscription already exists"
        );
    }

    function _checkSubscriptionLive(string memory _id) internal view {
        _checkSubscription(_id);

        require(
            _isSubscriptionLive(_id),
            "Subscription status is not live"
        );
    }

    function _isSubscriptionLive(string memory _id) internal view returns (bool) {
        return _isSubscriptionStatus(_id, "active") || _isSubscriptionStatus(_id, "waiting");
    }

    function _isSubscriptionStatus(string memory _id, string memory _status) internal view returns (bool) {
        return keccak256(abi.encodePacked(subscriptions[_id].status)) == keccak256(abi.encodePacked(_status));
    }

    function _checkSubscriptionTime(string memory _id) internal view {
        require(
            _isSubscriptionChargeTime(_id),
            "Subscription charge time is not yet"
        );
    }

    function _isSubscriptionChargeTime(string memory _id) internal view returns (bool) {
        return subscriptions[_id].chargeTime <= block.timestamp;
    }
}

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

import "./FanspayShare.sol";

interface TokenInterface {
    function allowance(address _owner, address _spender) external view returns (uint);

    function balanceOf(address _spender) external view returns (uint);

    function transferFrom(address _from, address _to, uint256 _value) external;
}

contract FanspayTokens is FanspayShare {
    constructor() {}
    function _isEnoughAllowanceAndBalance(address _address, uint _amount, address _tokenAddress) internal view returns (bool) {
        return _isEnoughAllowance(_address, _amount, _tokenAddress) && _isEnoughBalance(_address, _amount, _tokenAddress);
    }

    function _checkAllowance(address _address, uint _amount, address _tokenAddress) internal view {
        require(
            _isEnoughAllowance(_address, _amount, _tokenAddress),
            "Allowance not enough"
        );
    }

    function _isEnoughAllowance(address _address, uint _amount, address _tokenAddress) internal view returns (bool) {
        TokenInterface token = TokenInterface(_tokenAddress);
        uint allowance = token.allowance(_address, address(this));

        return _amount <= allowance;
    }

    function _checkBalance(address _address, uint _amount, address _tokenAddress) internal view {
        require(
            _isEnoughBalance(_address, _amount, _tokenAddress),
            "Balance not enough"
        );
    }

    function _isEnoughBalance(address _address, uint _amount, address _tokenAddress) internal view returns (bool) {
        TokenInterface token = TokenInterface(_tokenAddress);
        uint balance = token.balanceOf(_address);

        return _amount <= balance;
    }

    function _transferToken(address _from, Share[] memory _shareList, address _tokenAddress) internal {
        TokenInterface token = TokenInterface(_tokenAddress);

        for (uint i = 0; i < _shareList.length; i++) {
            token.transferFrom(_from, _shareList[i].receiver, _shareList[i].amount);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

{
  "compilationTarget": {
    "Fanspay.sol": "Fanspay"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}