pragma solidity ^0.5.0;
contract MyToken{

    struct Lot{
        address payable owner;
        uint tokens;
        uint price;
        uint index;
    }

    uint totalsupply;
    mapping (address => uint) tokenOwners;
    mapping (bytes32 => Lot) lots;
    bytes32[] hashLots;
    address payable owner;
    uint sellingRate;
    uint eth;
    bool closed;

    constructor (uint _sellingRate) public{
        owner = msg.sender;
        if (_sellingRate == 0)
        {
            sellingRate = 1;
        }
        else
        {
            sellingRate = _sellingRate;
        }
    }

    function totalSupply() public view returns (uint){
        return totalsupply;
    }

    function changeRate(uint _sellingRate) public {
        require(msg.sender == owner);
        if (_sellingRate != 0)
            sellingRate = _sellingRate;
        else
            sellingRate = 1;
    }

    function balanceOf(address tokenOwner) public view returns (uint balance){
         return balance = tokenOwners[tokenOwner];
    }

    function transfer(address to, uint tokens) public returns (bool success){
        if (tokenOwners[msg.sender] >= tokens){
            tokenOwners[msg.sender] -= tokens;
            tokenOwners[to] += tokens;
            emit Transfer(msg.sender, to, tokens);
            return true;
        }
        else{
            return false;
        }
    }

    function () external payable{
        require(!closed);
        totalsupply += msg.value / sellingRate;
        tokenOwners[msg.sender] =  msg.value / sellingRate;
        eth += msg.value;
    }

    function getETH() public{
        require(msg.sender == owner);
        owner.transfer(eth);
        eth = 0;
    }

    function close(bool _open) public{
        require(msg.sender == owner);
        closed = _open;
    }

    function placeLot(uint _tokens, uint price) public returns(bytes32 hash){
        require(closed && (tokenOwners[msg.sender] >= _tokens));
        if (price == 0)
            price = _tokens * sellingRate;
        tokenOwners[msg.sender] -= _tokens;
        bytes32 nowHash = sha256(abi.encodePacked(msg.sender, _tokens, now));
        lots[nowHash] = Lot(msg.sender, _tokens, _tokens * sellingRate, hashLots.push(nowHash) - 1);
        return nowHash;
    }

    function buyLot(bytes32 _lot) public payable{
        require(msg.value >= lots[_lot].price, "You need send ETH");
        if (msg.value >= lots[_lot].price){
            (msg.sender).transfer(msg.value - lots[_lot].price);
        }
        (lots[_lot].owner).transfer(lots[_lot].price);
        tokenOwners[msg.sender] += lots[_lot].tokens;
        hashLots[lots[_lot].index] = hashLots[hashLots.length - 1];
        hashLots.pop();
        delete lots[_lot];
    }

    function cancelLot(bytes32 _lot) public{
        require(lots[_lot].owner == msg.sender);
        tokenOwners[msg.sender] += lots[_lot].tokens;
        hashLots[lots[_lot].index] = hashLots[hashLots.length - 1];
        hashLots.pop();
        delete lots[_lot];
    }

    function getLotInfo(bytes32 _lot) public view returns(address payable addressOwner, uint tokens, uint price){
        return (lots[_lot].owner, lots[_lot].price, lots[_lot].price);
    }

    function getAllLots() public view returns(bytes32[] memory hashs){
        return hashLots;
    }

    event Transfer(address indexed from, address indexed to, uint tokens);
}