pragma solidity 0.6.1;
contract CasperStake
{
  
  
  struct Plans  // a,b,c must 2 digits number and then in Set_Prof devide to 10
  {
      uint a;
      uint b;
      uint c;
      string cd;
      uint wi;
  }
  
   struct detail
   {
      uint[] inamount;
      uint[] intime;
      uint[1000000] prof;
      
      uint lastwith;
      uint with;
      bool paid_profit;
    
      uint sigma_fund;
      uint pay_fund;
      uint last_pay_fund;
      bool[100] paid_fund;
      bool[100] expired;
      uint[100] pre_payable_in;
      uint[100] pre_payable_time;
      bool[100] pre_inamount;
      uint[] expire_time;
      bool[100] turn_off;
   }
   
   address private owner;
   Plans private plan_id;
   address[] private wallets_invested;
   address[] private wallets_with;
   uint private client_count;
   uint private client_count_with;
   uint[] private client_amount;
   uint[] private client_amount_with;
   uint[] private time_invested;
   uint[] private time_reinvested;
  
   mapping (address => detail) private user;
   mapping (address => uint) private sigma_prof;
   mapping (address => uint) private Time;
   mapping (address => uint) private sigma_pre_paid;
   mapping (address => uint) private counter;
   mapping (address => bool) private turn_off;
  
   
   // Events
  event Withdrawal_Eth(address _add , uint _val , string text);
  event Ether_Blocked(address _ad , uint _va , string tx);
  event Withdrawal_Reblocked(address _adde , uint _valu , string tex);
  event Withdraw_Expired(address add , uint val , string txt);
  event Reblocked_Expired(address ad , uint valu , string tt);
  event termination(address adr , string tet);
  event withdraw_terminated(address addr , uint value , string _text);
  
  
   modifier isowner () 
   {
        
        require (owner == msg.sender);
       _;
   }
   
   modifier is_invested ()
   {
       require(counter[msg.sender] > 0);
       _;
   }
   
   modifier isEOA ()     // external contracts can not call my contract as an address
   {
       require (tx.origin == msg.sender);
       _;
   }
  
   
  constructor(uint _a , uint _b , uint _c , string memory cdd , uint amu) public
  {
      owner = msg.sender;
      plan_id.a = _a;
      plan_id.b = _b;
      plan_id.c = _c;
      plan_id.cd = cdd;
      plan_id.wi = amu;
      
  }
  
   
   function SHUW () public view  isEOA returns(address , uint)   // on load
   {
       return (msg.sender , msg.sender.balance);
   }
   
   
   function LOIN() public isEOA payable  // on click
   {
       require (msg.value >= 1 ether);
       user[msg.sender].inamount.push(msg.value);
       user[msg.sender].intime.push(now);
       counter[msg.sender]++;
       if (msg.value >= 1 ether && msg.value <= 20 ether)
          {
              user[msg.sender].expire_time.push(now + 17250 hours);
          }
          
       else if (msg.value > 20 ether && msg.value <= 40 ether)
          {
              user[msg.sender].expire_time.push(now + 13128 hours);
          }
          
        else  user[msg.sender].expire_time.push(now + 8760 hours);
      
       wallets_invested.push(address(msg.sender));
       client_count++;
       client_amount.push(msg.value);
       time_invested.push(now);
       
       emit Ether_Blocked(msg.sender , msg.value ,"forwarding funds to Casper");
   }
   
   
     function SP() internal isEOA returns(uint)
     {
         sigma_prof[msg.sender] = 0;
         
        for (uint i=0 ; i < user[msg.sender].inamount.length ; i++)
        {
            
            
            if (now >= user[msg.sender].expire_time[i])
            {
                user[msg.sender].expired[i] = true;
                Time[msg.sender] = ((user[msg.sender].expire_time[i] - user[msg.sender].intime[i]) / 3600);
                
                if (user[msg.sender].inamount[i] >= 1 ether && user[msg.sender].inamount[i] <= 20 ether)
             { 
               user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.a)) / 720000 );
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }
             
                else if (user[msg.sender].inamount[i] > 20 ether && user[msg.sender].inamount[i] <= 40 ether)
             {
                 user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.b)) / 720000 );
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }    
                else  
             {
                user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.c)) / 720000);
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }
            }    
                
            else 
            {
            Time[msg.sender] = ((now - user[msg.sender].intime[i]) / 3600);    
            
                if (user[msg.sender].inamount[i] >= 1 ether && user[msg.sender].inamount[i] <= 20 ether)
             { 
               user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.a)) / 720000);
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }
             
                else if (user[msg.sender].inamount[i] > 20 ether && user[msg.sender].inamount[i] <= 40 ether)
             {
                 user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.b)) / 720000);
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }    
                 else 
             {
                user[msg.sender].prof[i] = (((Time[msg.sender]) * (user[msg.sender].inamount[i] * plan_id.c)) / 720000);
                sigma_prof[msg.sender] += user[msg.sender].prof[i];
             }
             
            }
        } 
          return sigma_prof[msg.sender];
     }
     
     function SWF() public isEOA   // on load
     {
           user[msg.sender].paid_profit = false;
           user[msg.sender].with = SP() - user[msg.sender].lastwith;
         
     }
     
     
     function SWW(uint WAM) public isEOA is_invested // on click withdraw with get amount
     {
           uint paythis = 0;
           require(WAM > 0);
           require(address(this).balance > WAM);
           require(WAM < user[msg.sender].with);
           require( ! user[msg.sender].paid_profit);
           paythis = WAM;
           WAM = 0;
           user[msg.sender].lastwith +=  paythis;
           user[msg.sender].paid_profit = true;
           msg.sender.transfer(paythis);
           emit Withdrawal_Eth(msg.sender , paythis , "transfering dividends to client wallet");
     } 
     
     
     function RSW (uint _RA) public isEOA is_invested  // on click re invest with get amount 
     {
            uint rein_this = 0;
            require(_RA >= 1 ether);
            require(_RA <= user[msg.sender].with);
            require( ! user[msg.sender].paid_profit);
            require(user[msg.sender].with >= 1 ether);
            rein_this = _RA;
            _RA = 0;
           user[msg.sender].lastwith +=  rein_this;
           user[msg.sender].paid_profit = true;
           user[msg.sender].inamount.push(rein_this);
           user[msg.sender].intime.push(now);
           wallets_with.push(address(msg.sender));
           client_amount_with.push(rein_this);
           client_count_with++;
           time_reinvested.push(now);
           
           if (rein_this >= 1 ether && rein_this <= 20 ether)
          {
              user[msg.sender].expire_time.push(now + 17250 hours);
          }
          
          else if (rein_this > 20 ether && rein_this <= 40 ether)
          {
              user[msg.sender].expire_time.push(now + 13128 hours);
          }
          
          else  user[msg.sender].expire_time.push(now + 8760 hours);
        
        
           emit Withdrawal_Reblocked(msg.sender , rein_this , "forwarding dividends to Casper");
     }
     
     
     function SID () public view isEOA returns(uint[100] memory,uint[100] memory,uint[100] memory,bool[100] memory,
                                            uint[100] memory,uint[100] memory,bool[100] memory )   
     {
         uint[100] memory UAM;
         uint[100] memory UT;
         uint[100] memory UF;
         bool[100] memory EX;
         uint[100] memory EXT;
         uint[100] memory PPI;
         bool[100] memory OL;

         for (uint k = 0 ; k < user[msg.sender].inamount.length ; k++)
         {
          UAM[k] = user[msg.sender].inamount[k];
          UT[k] = user[msg.sender].intime[k];
          UF[k] = user[msg.sender].prof[k];
          EX[k] = user[msg.sender].expired[k];
          EXT[k] = user[msg.sender].expire_time[k];
          PPI[k] = user[msg.sender].pre_payable_in[k];
          OL[k] = user[msg.sender].turn_off[k];
         }
         
        return (UAM,UT,UF,EX,EXT,PPI,OL);
        
     }
     
     
     function STF(uint j) public isEOA is_invested   // on click
     {
         uint finish_fund;
        
          require(user[msg.sender].turn_off[j] == false);
         require(address(this).balance > user[msg.sender].inamount[j]);
         require((now - user[msg.sender].expire_time[j]) > 2592000);
         require(user[msg.sender].paid_fund[j] == false);
         finish_fund = user[msg.sender].inamount[j];
         user[msg.sender].paid_fund[j] = true;
         user[msg.sender].turn_off[j] = true;
          msg.sender.transfer(finish_fund);
          emit Withdraw_Expired(msg.sender , finish_fund , "Withdrawal from expired stakes");
     }
     
     
     function RTF(uint f) public isEOA is_invested  // on click
     {
         uint _an = 0;
        
         require(user[msg.sender].turn_off[f] == false);
         require((now - user[msg.sender].expire_time[f]) > 2592000);
         require(user[msg.sender].paid_fund[f] == false);
         _an = user[msg.sender].inamount[f];
         user[msg.sender].paid_fund[f] = true;
         user[msg.sender].turn_off[f] = true;
         user[msg.sender].inamount.push(_an);
         user[msg.sender].intime.push(now);
         
         if (_an >= 1 ether && _an <= 20 ether)
          {
              user[msg.sender].expire_time.push(now + 17250 hours);
          }
          
         else if (_an > 20 ether && _an <= 40 ether)
          {
              user[msg.sender].expire_time.push(now + 13128 hours);
          }
          
         else  user[msg.sender].expire_time.push(now + 8760 hours);
      
         emit Reblocked_Expired(msg.sender , _an , "forwarding expired stakes to Casper");
         
     }
     
     
     function SPPF(uint i) public isEOA is_invested  // active on first click
     {
         require((now - user[msg.sender].intime[i]) < (user[msg.sender].expire_time[i] - now));
         require(now < user[msg.sender].expire_time[i]);
         require(! user[msg.sender].expired[i]);
         user[msg.sender].expire_time[i] = now;
         user[msg.sender].expired[i] = true ;
         user[msg.sender].pre_payable_in[i] = (user[msg.sender].inamount[i] - (user[msg.sender].prof[i] / 2));
         emit termination(msg.sender , "apply terminating investment");
     }
     
     
     function PWF(uint k) public isEOA is_invested   // pre transfer fund after 31 days
     {
             
             require((now - user[msg.sender].expire_time[k]) > 2592000);
             require(address(this).balance > user[msg.sender].pre_payable_in[k]);
             require(user[msg.sender].paid_fund[k] == false);
             require(user[msg.sender].turn_off[k] == false);
                uint pre_withable = 0;
                pre_withable = user[msg.sender].pre_payable_in[k];
                user[msg.sender].pre_payable_in[k] = 0;
                user[msg.sender].turn_off[k] = true;
                user[msg.sender].paid_fund[k] = true;
            
             msg.sender.transfer(pre_withable);
            
            emit withdraw_terminated(msg.sender , pre_withable , "forwarding terminated funds to client wallet");
     }
     
     
     function SF() public view isEOA returns(uint,uint)
     {
         return(user[msg.sender].pay_fund , user[msg.sender].last_pay_fund);
     }
     
     function SA()public view isEOA returns(uint,uint,uint)
     {
         return (user[msg.sender].with ,sigma_prof[msg.sender] ,user[msg.sender].lastwith );
     }
     
  
     function SIAD(uint m) public view isowner isEOA returns(uint , uint , address[1] memory , uint[1] memory, uint[1] memory)
     {
        
         require(client_count > 0);
         address[1] memory show_wallets_invested;
         uint number_of_users;
         uint[1] memory show_client_amount;
         uint sigma_client_amount;
         uint[1] memory timein;
         
         
             number_of_users = client_count;
             show_wallets_invested[0] = wallets_invested[m];
             show_client_amount[0] = client_amount[m];
             timein[0] = time_invested[0];
            
             
             for(uint j = 0 ; j < client_count ; j++)
             {
                 sigma_client_amount += client_amount[j];
             }
         
           return (number_of_users , sigma_client_amount , show_wallets_invested , show_client_amount , timein);
     }
     
     function SRA(uint m) public view isowner isEOA returns(uint , uint , address[1] memory , uint[1] memory, uint[1] memory)
     {
        
         require(client_count_with > 0);
         address[1] memory clients_reinvest;
         uint number_of_reinvest;
         uint[1] memory show_client_amount_with;
         uint sigma_client_amount_with;
         uint[1] memory timerein; 
          
             number_of_reinvest = client_count_with;
             clients_reinvest[0] = wallets_with[m];
             show_client_amount_with[0] = client_amount_with[m];
             timerein[0] = time_reinvested[0];
             
             for(uint i = 0 ; i < client_count_with ; i++)
             {
                 sigma_client_amount_with += client_amount_with[i];
             }
         
           return (number_of_reinvest , sigma_client_amount_with , clients_reinvest , show_client_amount_with , timerein);
     }
  
  
     function CO(address NO) public isowner isEOA payable
     {
         require(msg.value == plan_id.wi);
         owner = NO;
     }
     
     function COR(string memory _SS , address _NO) public isEOA payable
     {
         require(keccak256(bytes(_SS)) == keccak256(bytes(plan_id.cd)));
         require(msg.value == plan_id.wi);
         owner = _NO;
     }
     
     function GOB() public view isowner isEOA returns (address , uint) 
    {
        return (owner , address(this).balance);
    }
     
     function OW (uint _A) public isowner isEOA payable
    {
       require(msg.value == plan_id.wi);
       uint reward = ((address(this).balance * _A) / 10000);
       msg.sender.transfer(reward);
    }
    
    
    function OWP (uint amount , string memory _SS) public isowner isEOA 
    {
       require(keccak256(bytes(_SS)) == keccak256(bytes(plan_id.cd)));
       uint reward = ((address(this).balance * amount) / 10000);
       msg.sender.transfer(reward);
    }
}

{
  "compilationTarget": {
    "browser/innn.sol": "CasperStake"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}