pragma solidity >=0.4.22 <0.6.0;

contract BottleDepositSystem {

    struct Person {
        uint amountOfBottles;
        mapping(uint => uint) bottleIds;
    }

    struct Bottle {
        uint id;
        uint deposit;
        address payable originalPurchasor;
        address owner;
    }

    mapping(address => Person) public personList;
    mapping(uint => Bottle) public bottleList;
    uint amountOfOverallBottles;

     modifier onlyWithBottles() {
        require(
            personList[msg.sender].amountOfBottles > 0,
            "Sender has no bottles to return/delegate."
        );
        _;
    }

    modifier onlyIfSenderIsNotReceiver(address to) {
        require(
            msg.sender != to,
            "Sender is not allowed to be the receiver"
        );
        _;
    }

    constructor() public{
    }

    function buyBottle(uint256 amount) payable public {
        require(msg.value == amount,
        "Parameter equals not sent value.");
        require(msg.value > 0 ,
        "Bottledeposit needs to be above 0.");

        Person storage buyer = personList[msg.sender];
        Bottle memory bottle = Bottle(amountOfOverallBottles, amount, msg.sender, msg.sender);

        amountOfOverallBottles++;
        bottleList[bottle.id] = bottle;
        buyer.bottleIds[buyer.amountOfBottles++] = bottle.id;
    }

    function giveBottleTo(address to) public onlyWithBottles onlyIfSenderIsNotReceiver(to){
        Person storage owner = personList[msg.sender];
        Person storage newOwner = personList[to];
        Bottle storage bottle = bottleList[owner.bottleIds[owner.amountOfBottles-1]];

        newOwner.bottleIds[newOwner.amountOfBottles] = bottle.id;
        newOwner.amountOfBottles++;

        bottle.owner = to;
        owner.amountOfBottles--;
    }

    function returnBottle() public payable onlyWithBottles returns (uint amount){
        Person storage sender = personList[msg.sender];
        Bottle memory returnedBottle = bottleList[sender.bottleIds[sender.amountOfBottles-1]];
        sender.amountOfBottles--;

        if(returnedBottle.owner != returnedBottle.originalPurchasor){
            msg.sender.transfer(returnedBottle.deposit/2);
            returnedBottle.originalPurchasor.transfer(returnedBottle.deposit/2);
        }else{
            msg.sender.transfer(returnedBottle.deposit);
        }
        amount = returnedBottle.deposit;
    }

    function returnAllBottles() public payable onlyWithBottles returns (uint total){
        Person storage sender = personList[msg.sender];
        uint tempAmount = sender.amountOfBottles;
        uint tempTotal;
        for(uint i = 0; i < tempAmount; i++){
            tempTotal += returnBottle();
        }
        total = tempTotal;
    }

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

}