pragma solidity ^0.4.4;

/**
* Ponzischeme.io - Published on 1st April 2018.
* 
* Financial Pyramid for Dummies:
*
* A pyramid scheme is a business model that recruits members via a promise of payments 
* for enrolling others into the scheme, rather than supplying investments or sale 
* of products or services. [source: https://en.wikipedia.org/wiki/Pyramid_scheme] 
*
* How Ponzischeme.io works in an example:
*
* 1. You buy a Ponzi Token with level 4 for 0.001 ETH
* 2. It's listed for sale automatically for 0.002 ETH
* 3. Previous owner is getting 0.0005 ETH immediately (he paid for his Ponzi Token exactly that)
* 4. He will receive the second half (minus fee) only after someone will buy it from you.
* 5. Thanks to this *successfull investment* strategy you can always return the Ponzi Token  
*    you own for a 50% of the price you paid. Do it only if you don't want to wait for 
*    a next buyer.  
* 6. When someone will buy your Ponzi Token (for 0.002 ETH) you will receive 0.001 ETH immediately, 
*    and a second half (minus fee) when someone will buy it from him (*successfull investment*).
*
* Fee is charged only from a successful investment and is being used for rewarding owners of  
* Ponzi Tokens with higher levels from the one purchased. There is no fee for purchasing 
* the strongest token. 
*
* In example listed above fee will looks as follows:
* - You bought a Ponzi Token with level 4 for a 0.001 ETH 
* - Fee is 10% and it gives 0.0001 ETH
* - Owners of Ponzi Tokens with level 1, 2 and 3 will receive:
* - Level 1: 0.00005     (1/2)
* - Level 2: 0.000025    (1/4)
* - Level 3: 0.0000125   (1/8)
* - Level 1 (again): 0.0000125 (the rest after fee division)
* - Owners of levels 5 and 6 won't receive anything extra in this example.
*
* As you see, owning tokens with higher level is better (especially the first one).
*
* In code/comments we use words such as:
* Buyer - someone who is buying a Ponzi Token (he pays a price and becomes Owner)
* Owner - current owner of a token (he gets 1/2 of a price Buyer paid, and becomes Beneficient)
* Beneficient - previous owner of a token (he gets a second half of a price minus fee)
*/

//@TODO implement an ERC20 Token Interface to be listed on Coinbase
contract PonziScheme {

    // How much fee is charged from a successful investment
    uint8 feeInPercent = 10; 
    // Account of smart contract creator. It's is used only once in destructor.
    address public masterAccount = msg.sender;

    /******************** 
     *   PONZI TOKENS   *
     ********************/
     
    // How many tokens exists 
    uint8 tokens = 6;
    // Tokens prices
    uint[6] public tokensPrices;
    // Their owners
    address[6] public tokensOwners;
    // Beneficient is a person who is waiting for a 90% reward from his/her token
    address[6] public tokensBeneficients;    

    /**
     * Smart Contract Constructor
     */
    function PonziScheme() public {
        for(uint8 i = 0; i < tokens; i++) {
            // Starting price in WAI, equivalent to 0.0001 ETH 
            tokensPrices[i] = 100000000000000;            
            // At the beginning there is no owner.
            tokensOwners[i] = address(0x0);
        }
    }

    /**
     * Transfer ETH if address not equal to 0x0
     */ 
    function secureTransfer(address to, uint amount) private returns (bool success) {
        if(to != address(0x0) && amount > 0) {
            to.transfer(amount);
            return true;
        }

        return false;
    }

    /************** 
     *   MARKET   *
     **************/

    /**
     * Buy a Ponzi Token on the market.
     *
     * Note: I don't check if user is a current token owner beacuse 
     * he may want to pump the price.
     */
    function buy(uint8 token) public payable {
        // Check if token exists
        require(token >= 0 && token < tokens);
        // Check if user has sent correct amount of ETH
        require(msg.value == tokensPrices[token]);

        // How much I pay?
        uint currentPrice = tokensPrices[token];
        // How much owner paid?
        uint ownerPrice = currentPrice/2;

        /**
         * Set new price
         */
        tokensPrices[token] *= 2;  

        /** 
         * Calculate fees
         */
        // Fee is charged from a successful investment (the one before this purchase).
        uint fee = feeInPercent * ownerPrice / 100; 

        /**
         * Payouts
         */

        // Beneficient got earlier (as owner) 1/2 of the price and now 
        // I send him a second half minus fee.           
        if(tokensBeneficients[token] != address(0x0)) {

            address beneficient = tokensBeneficients[token];
            tokensBeneficients[token] = address(0x0);
                      
            uint missingAmount = ownerPrice/2 - fee;         
            secureTransfer(beneficient, missingAmount);
            /* Success story */
            /* Someone have got 90% return on his investment */                        
        }

        // Current owner gets here the same amount as he paid. He will get reward (90% more) 
        // when someone will buy token from the new buyer.
        secureTransfer(tokensOwners[tokens], ownerPrice);
        /* Little success story. Now he shouldn't lose his/her investment. */

        // Every Ponzi Token HODLer with level higher than the current token will get part 
        // of a fee
        uint ownersFee = fee;   
        uint8 i;     
        for(i = 0; i < token; i++) {
            if(tokensOwners[i] == address(0x0)) continue;

            ownersFee = ownersFee / 2;
            fee -= ownersFee;

            secureTransfer(tokensOwners[i], ownersFee);
        }        

        // Owner of the first not empty token get the rest of fee 
        // It implies that there is no fee for purchasing the highest level token        
        for(i = 0; i < tokens; i++) {
            if(tokensOwners[i] == address(0x0)) continue;
            secureTransfer(tokensOwners[i], fee);    
            break;
        }

        /**
         * Set the new owners
         */
        tokensBeneficients[token] = tokensOwners[token];                  
        tokensOwners[token] = msg.sender;               
    }

    /**
     * Return token and get 50% of investment back.
     *
     * Use it only when you don't want to wait for a new buyer. 
     * You will lose 50% of your investment beacuse the first half 
     * was sent to an old owner immediately after purchase.
     */
    function cancelOrder(uint8 token) public {
        // Check if token exists
        require(token >= 0 && token <= tokens);
        // Check if sender is token owner
        require(msg.sender == tokensOwners[token]);

        // Preventing reentrancy Attack
        tokensOwners[token] = address(0x0);

        // Return to user a half of the price he paid. We use 1/4 beacuse price 
        // is always increased by 2x after purchase.
        uint amountToReturn = tokensPrices[token]/4;
        secureTransfer(msg.sender, amountToReturn);   
        /* Sad story. He or she just lost 50% of his/her investment */   

        // Old owner becomes current owner. 
        tokensOwners[token] = tokensBeneficients[token];

        // One who is returning token becomes Beneficient. 
        //         
        // If someone will buy token from a new owner, Beneficient will 
        // receive 1/2 of a price minus fee. His final losses could be lower, 
        // maybe ~25%.
        tokensBeneficients[token] = msg.sender;

        // Lower the price to a more attractive one.
        tokensPrices[token] /= 2;        
    }

    /**
     * Destructor
     *
     * If something will go terribly wrong (e.g hackers will do their job) 
	 * I will return all remaining ETH and delete contract.
     */
    function thisDeveloperSucks() public {
        require(msg.sender == masterAccount);

        uint8 i;

        for(i = 0; i < tokens; i++) {

            // Owner paid 1/2 of the current price but we can return him
            // only half of it. The first half was sent earlier to previous owner 
            // when he sold his Ponzi Token.
            // 
            // You knew the risks, right? 
            uint amountToReturn = tokensPrices[i]/4;
            secureTransfer(tokensOwners[i], amountToReturn);   
        }

        // If there is ETH left return it to the first token owner and delete contract
        for(i = 0; i < tokens; i++) {
            if(tokensOwners[i] != address(0x0)) {
                selfdestruct(tokensOwners[i]);
            }
        }
    }    
}