pragma solidity ^0.4.25;

/* solium-disable error-reason */

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    /**
    * @dev Multiplies two numbers, reverts on 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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two numbers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        require(token.transfer(to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        require(token.transferFrom(from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require((value == 0) || (token.allowance(msg.sender, spender) == 0));
        require(token.approve(spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        require(token.approve(spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        require(token.approve(spender, newAllowance));
    }
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @author Remco Bloemen <remco@2π.com>, Eenae <alexey@mixbytes.io>
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @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 make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter);
    }
}

/**
 * @title Crowdsale
 * @dev Crowdsale is a base contract for managing a token crowdsale,
 * allowing investors to purchase tokens with ether. This contract implements
 * such functionality in its most fundamental form and can be extended to provide additional
 * functionality and/or custom behavior.
 * The external interface represents the basic interface for purchasing tokens, and conform
 * the base architecture for crowdsales. They are *not* intended to be modified / overridden.
 * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
 * the methods to add functionality. Consider using 'super' where appropriate to concatenate
 * behavior.
 */
contract Crowdsale is ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // The token being sold
    IERC20 private _token;

    // Address where funds are collected
    address private _wallet;

    // How many token units a buyer gets per wei.
    // The rate is the conversion between wei and the smallest and indivisible token unit.
    // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
    // 1 wei will give you 1 unit, or 0.001 TOK.
    uint256 private _rate;

    // Amount of wei raised
    uint256 private _weiRaised;

    /**
     * Event for token purchase logging
     * @param purchaser who paid for the tokens
     * @param beneficiary who got the tokens
     * @param value weis paid for purchase
     * @param amount amount of tokens purchased
     */
    event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);

    /**
     * @param rate Number of token units a buyer gets per wei
     * @dev The rate is the conversion between wei and the smallest and indivisible
     * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
     * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
     * @param wallet Address where collected funds will be forwarded to
     * @param token Address of the token being sold
     */
    constructor (uint256 rate, address wallet, IERC20 token) internal {
        require(rate > 0);
        require(wallet != address(0));
        require(token != address(0));

        _rate = rate;
        _wallet = wallet;
        _token = token;
    }

    // -----------------------------------------
    // Crowdsale external interface
    // -----------------------------------------

    /**
     * @dev fallback function ***DO NOT OVERRIDE***
     * Note that other contracts will transfer fund with a base gas stipend
     * of 2300, which is not enough to call buyTokens. Consider calling
     * buyTokens directly when purchasing tokens from a contract.
     */
    function () external payable {
        buyTokens(msg.sender);
    }

    /**
     * @return the token being sold.
     */
    function token() public view returns (IERC20) {
        return _token;
    }

    /**
     * @return the address where funds are collected.
     */
    function wallet() public view returns (address) {
        return _wallet;
    }

    /**
     * @return the number of token units a buyer gets per wei.
     */
    function rate() public view returns (uint256) {
        return _rate;
    }

    /**
     * @return the amount of wei raised.
     */
    function weiRaised() public view returns (uint256) {
        return _weiRaised;
    }

    /**
     * @dev low level token purchase ***DO NOT OVERRIDE***
     * This function has a non-reentrancy guard, so it shouldn't be called by
     * another `nonReentrant` function.
     * @param beneficiary Recipient of the token purchase
     */
    function buyTokens(address beneficiary) public nonReentrant payable {
        uint256 weiAmount = msg.value;
        _preValidatePurchase(beneficiary, weiAmount);

        // calculate token amount to be created
        uint256 tokens = _getTokenAmount(weiAmount);

        // update state
        _weiRaised = _weiRaised.add(weiAmount);

        _processPurchase(beneficiary, tokens);
        emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);

        _updatePurchasingState(beneficiary, weiAmount);

        _forwardFunds();
        _postValidatePurchase(beneficiary, weiAmount);
    }

    // -----------------------------------------
    // Internal interface (extensible)
    // -----------------------------------------

    /**
     * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. Use `super` in contracts that inherit from Crowdsale to extend their validations.
     * Example from CappedCrowdsale.sol's _preValidatePurchase method:
     *     super._preValidatePurchase(beneficiary, weiAmount);
     *     require(weiRaised().add(weiAmount) <= cap);
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        require(beneficiary != address(0));
        require(weiAmount != 0);
    }

    /**
     * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid conditions are not met.
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        // optional override
    }

    /**
     * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends its tokens.
     * @param beneficiary Address performing the token purchase
     * @param tokenAmount Number of tokens to be emitted
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
        _token.safeTransfer(beneficiary, tokenAmount);
    }

    /**
     * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send tokens.
     * @param beneficiary Address receiving the tokens
     * @param tokenAmount Number of tokens to be purchased
     */
    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
        _deliverTokens(beneficiary, tokenAmount);
    }

    /**
     * @dev Override for extensions that require an internal state to check for validity (current user contributions, etc.)
     * @param beneficiary Address receiving the tokens
     * @param weiAmount Value in wei involved in the purchase
     */
    function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
        // optional override
    }

    /**
     * @dev Override to extend the way in which ether is converted to tokens.
     * @param weiAmount Value in wei to be converted into tokens
     * @return Number of tokens that can be purchased with the specified _weiAmount
     */
    function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
        return weiAmount.mul(_rate);
    }

    /**
     * @dev Determines how ETH is stored/forwarded on purchases.
     */
    function _forwardFunds() internal {
        _wallet.transfer(msg.value);
    }
}

/**
 * @title CappedCrowdsale
 * @dev Crowdsale with a limit for total contributions.
 */
contract CappedCrowdsale is Crowdsale {
    using SafeMath for uint256;

    uint256 private _cap;

    /**
     * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
     * @param cap Max amount of wei to be contributed
     */
    constructor (uint256 cap) internal {
        require(cap > 0);
        _cap = cap;
    }

    /**
     * @return the cap of the crowdsale.
     */
    function cap() public view returns (uint256) {
        return _cap;
    }

    /**
     * @dev Checks whether the cap has been reached.
     * @return Whether the cap was reached
     */
    function capReached() public view returns (bool) {
        return weiRaised() >= _cap;
    }

    /**
     * @dev Extend parent behavior requiring purchase to respect the funding cap.
     * @param beneficiary Token purchaser
     * @param weiAmount Amount of wei contributed
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        super._preValidatePurchase(beneficiary, weiAmount);
        require(weiRaised().add(weiAmount) <= _cap);
    }
}

/**
 * @title TimedCrowdsale
 * @dev Crowdsale accepting contributions only within a time frame.
 */
contract TimedCrowdsale is Crowdsale {
    using SafeMath for uint256;

    uint256 private _openingTime;
    uint256 private _closingTime;

    /**
     * @dev Reverts if not in crowdsale time range.
     */
    modifier onlyWhileOpen {
        require(isOpen());
        _;
    }

    /**
     * @dev Constructor, takes crowdsale opening and closing times.
     * @param openingTime Crowdsale opening time
     * @param closingTime Crowdsale closing time
     */
    constructor (uint256 openingTime, uint256 closingTime) internal {
        // solium-disable-next-line security/no-block-members
        require(openingTime >= block.timestamp);
        require(closingTime > openingTime);

        _openingTime = openingTime;
        _closingTime = closingTime;
    }

    /**
     * @return the crowdsale opening time.
     */
    function openingTime() public view returns (uint256) {
        return _openingTime;
    }

    /**
     * @return the crowdsale closing time.
     */
    function closingTime() public view returns (uint256) {
        return _closingTime;
    }

    /**
     * @return true if the crowdsale is open, false otherwise.
     */
    function isOpen() public view returns (bool) {
        // solium-disable-next-line security/no-block-members
        return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
    }

    /**
     * @dev Checks whether the period in which the crowdsale is open has already elapsed.
     * @return Whether crowdsale period has elapsed
     */
    function hasClosed() public view returns (bool) {
        // solium-disable-next-line security/no-block-members
        return block.timestamp > _closingTime;
    }

    /**
     * @dev Extend parent behavior requiring to be within contributing period
     * @param beneficiary Token purchaser
     * @param weiAmount Amount of wei contributed
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
        super._preValidatePurchase(beneficiary, weiAmount);
    }
}

/**
 * @title FthCrowdsale
 */
contract FthCrowdsale is CappedCrowdsale, TimedCrowdsale {
    using SafeMath for uint256;

    uint256 constant MIN_WEI_AMOUNT = 0.1 ether;

    uint256 private _rewardPeriod;
    uint256 private _unlockPeriod;

    struct Contribution {
        uint256 contributeTime;
        uint256 buyTokenAmount;
        uint256 rewardTokenAmount;
        uint256 lastWithdrawTime;
        uint256 withdrawPercent;
    }

    mapping(address => Contribution[]) private _contributions;

    constructor (
        uint256 rewardPeriod,
        uint256 unlockPeriod,
        uint256 cap,
        uint256 openingTime,
        uint256 closingTime,
        uint256 rate,
        address wallet,
        IERC20 token
    )
        public
        CappedCrowdsale(cap)
        TimedCrowdsale(openingTime, closingTime)
        Crowdsale(rate, wallet, token)
    {
        _rewardPeriod = rewardPeriod;
        _unlockPeriod = unlockPeriod;
    }

    function contributionsOf(address beneficiary)
        public
        view
        returns (
            uint256[] memory contributeTimes,
            uint256[] memory buyTokenAmounts,
            uint256[] memory rewardTokenAmounts,
            uint256[] memory lastWithdrawTimes,
            uint256[] memory withdrawPercents
        )
    {
        Contribution[] memory contributions = _contributions[beneficiary];

        uint256 length = contributions.length;

        contributeTimes = new uint256[](length);
        buyTokenAmounts = new uint256[](length);
        rewardTokenAmounts = new uint256[](length);
        lastWithdrawTimes = new uint256[](length);
        withdrawPercents = new uint256[](length);

        for (uint256 i = 0; i < length; i++) {
            contributeTimes[i] = contributions[i].contributeTime;
            buyTokenAmounts[i] = contributions[i].buyTokenAmount;
            rewardTokenAmounts[i] = contributions[i].rewardTokenAmount;
            lastWithdrawTimes[i] = contributions[i].lastWithdrawTime;
            withdrawPercents[i] = contributions[i].withdrawPercent;
        }
    }

    function withdrawTokens(address beneficiary) public {
        require(isOver());

        if (msg.sender == beneficiary && msg.sender == wallet()) {
            _withdrawTokensToWallet();
        } else {
            _withdrawTokensTo(beneficiary);
        }
    }

    function unlockBalanceOf(address beneficiary) public view returns (uint256) {
        uint256 unlockBalance = 0;

        Contribution[] memory contributions = _contributions[beneficiary];

        for (uint256 i = 0; i < contributions.length; i++) {
            uint256 unlockPercent = _unlockPercent(contributions[i]);

            if (unlockPercent == 0) {
                continue;
            }

            unlockBalance = unlockBalance.add(
                contributions[i].buyTokenAmount.mul(unlockPercent).div(100)
            ).add(
                contributions[i].rewardTokenAmount.mul(unlockPercent).div(100)
            );
        }

        return unlockBalance;
    }

    function rewardTokenAmount(uint256 buyTokenAmount) public view returns (uint256) {
        if (!isOpen()) {
            return 0;
        }

        uint256 rewardTokenPercent = 0;

        // solium-disable-next-line security/no-block-members
        uint256 timePeriod = block.timestamp.sub(openingTime()).div(_rewardPeriod);

        if (timePeriod < 1) {
            rewardTokenPercent = 15;
        } else if (timePeriod < 2) {
            rewardTokenPercent = 10;
        } else if (timePeriod < 3) {
            rewardTokenPercent = 5;
        } else {
            return 0;
        }

        return buyTokenAmount.mul(rewardTokenPercent).div(100);
    }

    function rewardPeriod() public view returns (uint256) {
        return _rewardPeriod;
    }

    function unlockPeriod() public view returns (uint256) {
        return _unlockPeriod;
    }

    function isOver() public view returns (bool) {
        return capReached() || hasClosed();
    }

    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        require(weiAmount >= MIN_WEI_AMOUNT);

        super._preValidatePurchase(beneficiary, weiAmount);
    }

    function _processPurchase(address beneficiary, uint256 buyTokenAmount) internal {
        Contribution[] storage contributions = _contributions[beneficiary];
        require(contributions.length < 100);

        contributions.push(Contribution({
            // solium-disable-next-line security/no-block-members
            contributeTime: block.timestamp,
            buyTokenAmount: buyTokenAmount,
            rewardTokenAmount: rewardTokenAmount(buyTokenAmount),
            lastWithdrawTime: 0,
            withdrawPercent: 0
        }));
    }

    function _withdrawTokensToWallet() private {
        uint256 balanceTokenAmount = token().balanceOf(address(this));
        require(balanceTokenAmount > 0);

        _deliverTokens(wallet(), balanceTokenAmount);
    }

    function _withdrawTokensTo(address beneficiary) private {
        uint256 unlockBalance = unlockBalanceOf(beneficiary);
        require(unlockBalance > 0);

        Contribution[] storage contributions = _contributions[beneficiary];

        for (uint256 i = 0; i < contributions.length; i++) {
            uint256 unlockPercent = _unlockPercent(contributions[i]);

            if (unlockPercent == 0) {
                continue;
            }

            // solium-disable-next-line security/no-block-members
            contributions[i].lastWithdrawTime = block.timestamp;
            contributions[i].withdrawPercent = contributions[i].withdrawPercent.add(unlockPercent);
        }

        _deliverTokens(beneficiary, unlockBalance);
    }

    function _unlockPercent(Contribution memory contribution) private view returns (uint256) {
        if (contribution.withdrawPercent >= 100) {
            return 0;
        }

        uint256 baseTimestamp = contribution.contributeTime;

        if (contribution.lastWithdrawTime > baseTimestamp) {
            baseTimestamp = contribution.lastWithdrawTime;
        }

        // solium-disable-next-line security/no-block-members
        uint256 period = block.timestamp.sub(baseTimestamp);

        if (period < _unlockPeriod) {
            return 0;
        }

        uint256 unlockPercent = period.div(_unlockPeriod).sub(1).mul(10);

        if (contribution.withdrawPercent == 0) {
            unlockPercent = unlockPercent.add(50);
        } else {
            unlockPercent = unlockPercent.add(10);
        }

        uint256 max = 100 - contribution.withdrawPercent;

        if (unlockPercent > max) {
            unlockPercent = max;
        }

        return unlockPercent;
    }
}