pragma solidity >=0.4.22 <0.7.0;

contract kloan {
    mapping(address => bool) public Lender;
    mapping(address => bool) public Borrower;
    mapping(address => uint) public balances;
    mapping(address => loan) public contractK;

    struct loan{
        address lender;
        address borrower;
        uint amount;
        uint installments;
        uint expire;
        uint interest;
        uint total;
        uint pay;
        address tx;
    }
    
    function () external payable {
        if(Borrower[msg.sender]){
            Installment();
        }else{
           deposit();  
        }
       
    }
    
    function deposit() internal {
        Lender[msg.sender] = true;
        balances[msg.sender] += msg.value;
    }
    function okloan(uint _amount, address _lender, uint _installments) public returns (bool){
        require(!Lender[msg.sender]);
        require(balances[_lender] >= _amount);
        uint _interest = 5;
        loan storage x = contractK[msg.sender];
        x.lender = _lender;
        x.borrower = msg.sender;
        x.amount = _amount;
        x.installments = _installments;
        x.expire = now + 7 days;
        x.interest = _interest;
        x.total = ((_interest/100)*_amount) + _amount;
        x.pay = x.total/_installments;
        x.tx = tx.origin;
        msg.sender.transfer(_amount);
        
        Borrower[msg.sender] = true;
        return true;
    }
    function Installment() internal{
        
        loan storage x = contractK[msg.sender];
        require(x.pay == msg.value);
        require(now < x.expire, 'sorry this contract expire !');
        if(x.installments == 1) {
            require(x.amount >= msg.value);
            Borrower[msg.sender] = false;
        }
        x.installments -= 1;
        x.amount -= msg.value;
        convertAddress(x.lender).transfer(msg.value);
    }
    
    function convertAddress(address _lender) internal pure returns (address payable) {
        return address(uint160(_lender));
    }
   
}