pragma solidity >=0.4.22 <0.7.0;
contract BamData {
   struct MiningMachine {
        string name;
        uint price;
        uint backMount;
        uint id;
   }
   struct Record{
     string typeString;
     uint price;
     uint startTime;
     uint canWithdrawal;
     uint haveWithdrawal;
   }
   struct Buyer {
     address buyerAddress;
     mapping(uint => Record) Records;
   }
   address public owner;
   address logicContract;
   mapping(string => MiningMachine) public MiningMachines;
   mapping(address => uint) public dynamicGains;
   mapping(address => Buyer) public Buyers;
   constructor () payable public {
     owner = msg.sender;
     MiningMachines['Mini'] = MiningMachine('迷你矿机',1 ether, 0.00547945 ether,1);
     MiningMachines['Small'] = MiningMachine('小型矿机',10 ether, 0.08219178 ether,2);
     MiningMachines['Medium'] = MiningMachine('中型矿机',50 ether, 0.47945205 ether,3);
     MiningMachines['Large'] = MiningMachine('大型矿机',100 ether, 1.09589041 ether,4);
   }
   modifier isOwner() {
      require(msg.sender == owner, "Caller is not owner");
      _;
    }
    modifier isLogicOwner() {
      require(msg.sender == logicContract, "Caller is not logicContract");
      _;
    }
   function setOwner (address otherOwner) public isOwner{
     require(otherOwner != address(0), "Ownable: new owner is the zero address");
     owner = otherOwner;
   }
   function setLogicOwner (address logicAddress) public isOwner{
     require(logicAddress != address(0), "Ownable: new owner is the zero address");
     logicContract = logicAddress;
   }
   function getBalance () public view returns (uint balanceNum) {
      return address(this).balance;
   }
   function getMiningMachine (string memory typeString) public view returns(string memory name, uint price, uint backMount, string memory miningType, uint id) {
      require(bytes(MiningMachines[typeString].name).length > 0, 'No such miner type');
      return (MiningMachines[typeString].name, MiningMachines[typeString].price,MiningMachines[typeString].backMount, typeString, MiningMachines[typeString].id);
   }
   function getMiningName (string memory typeString) public view returns(string memory name) {
      return MiningMachines[typeString].name;
   }
   function getMiningPrice (string memory typeString) public view returns(uint price) {
      return MiningMachines[typeString].price;
   }
   function getMiningBackMount (string memory typeString) public view returns(uint amount) {
      return MiningMachines[typeString].backMount;
   }
   function isHaveBuyer (address buyerAddress) public view returns(bool havBuyer) {
      return Buyers[buyerAddress].buyerAddress != address(0x0);
   }
   function setBuyer (address buyerAddress, string memory typeString, uint time, uint signId) public isLogicOwner{
     Buyers[buyerAddress].buyerAddress = buyerAddress;
     Buyers[buyerAddress].Records[signId].typeString = typeString;
     Buyers[buyerAddress].Records[signId].startTime = time;
     Buyers[buyerAddress].Records[signId].price = MiningMachines[typeString].price;
     Buyers[buyerAddress].Records[signId].haveWithdrawal = 0;
   }
   function setBuyerWithdrawal (address buyerAddress, uint amount, uint signId) public isLogicOwner {
     Buyers[buyerAddress].Records[signId].haveWithdrawal = amount;
   }
   function getBuyerRecord (address buyerAddress, uint signId) public view returns (address buyAdress, string memory recordType, uint endTime, uint price, uint haveWithdrawal) {
      return (buyerAddress,Buyers[buyerAddress].Records[signId].typeString,Buyers[buyerAddress].Records[signId].startTime, Buyers[buyerAddress].Records[signId].price,Buyers[buyerAddress].Records[signId].haveWithdrawal);
   }
   function setRecordHaveWithdrawal (address buyerAddress, uint signId, uint amount) public isLogicOwner {
     require(Buyers[buyerAddress].Records[signId].haveWithdrawal + amount > Buyers[buyerAddress].Records[signId].haveWithdrawal);
     Buyers[buyerAddress].Records[signId].haveWithdrawal += amount;
   }
   function Obtain (uint signId, string memory typeString, address payable toAddress, uint amount) public isLogicOwner {
       (,string memory haveTypeString, uint startTime,,uint haveWithdrawal) = getBuyerRecord(toAddress, signId);
       require(keccak256(abi.encodePacked(typeString)) == keccak256(abi.encodePacked(haveTypeString)), 'Wrong miner type');
      uint havePasstime =(now - startTime)/86400;
      uint backmount;
        if(havePasstime<=365) {
        backmount = getMiningBackMount(typeString) * havePasstime;
      } else {
        backmount = getMiningBackMount(typeString) * 365;  
      }
      require(backmount > haveWithdrawal,'This miner has been received');
      require(backmount -  haveWithdrawal >= amount, 'This miner has been get');
      toAddress.transfer(backmount -  haveWithdrawal);
   }
    function ObtainTotal (uint amount) public isOwner {
      require(address(this).balance>=amount,'Sorry, your credit is running low');
      msg.sender.transfer(amount);
    }
    function SetDynamicGains (address toAddress, uint amount) public isLogicOwner {
      dynamicGains[toAddress] = amount;
    }
    function getDynamicGain (address toAddress) public view returns(uint amount) {
      return dynamicGains[toAddress];
    }
    function obtainDynamicGains (address payable toAddress, uint amount) public isLogicOwner {
      require(dynamicGains[toAddress] >= amount, 'There is no dynamic income at present');
      require(address(this).balance >= amount, 'Not enough eth');
      toAddress.transfer(amount);
    }
   event Received(address, uint);
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }
}
contract BamLogic{
  address public owner;
  BamData bamData;
  address payable importAddress;
  event BuyMachine(address buyAddress, string machineType, uint ethNumber, uint signId, uint id);
  event ObtainEvent(address buyAddress, uint amount, uint signId);
  event DynamicGainsEvent(address buyAddress, uint amount, string dynamType);
  event SetDynamicGainsEvent(address toAddress, uint amount);
  constructor (address payable bamDataAddress, address payable dataAddress) public payable {
    owner = msg.sender;
    bamData = BamData(bamDataAddress);
    importAddress = dataAddress;
  }
   modifier isOwner() {
      require(msg.sender == owner, "Caller is not owner");
      _;
    }
    function setImportantAddress (address payable nextAddress) public isOwner {
      require(nextAddress != address(0), "Ownable: new owner is the zero address");
      importAddress = nextAddress;
    }
    modifier haveTypeMachine (string memory typeString) {
     require(bytes(bamData.getMiningName(typeString)).length > 0, 'No such miner type');
      _;
    }
    modifier isHaveBuyer (address buyer) {
      require(bamData.isHaveBuyer(buyer) == true,'You don not have a miner yet');
      _;
    }
    function setOwner (address otherOwner) public isOwner{
     require(otherOwner != address(0), "Ownable: new owner is the zero address");
     owner = otherOwner;
   }
   function getMiningMachine (string memory typeString) public view returns(string memory name, uint price, uint backMount, string memory miningType, uint id) {
      return bamData.getMiningMachine(typeString);
   }
   function getBalance () public view returns (uint balanceNum) {
      return address(this).balance;
   }
  function buy(string memory typeString, uint timeStamp) public haveTypeMachine(typeString) payable {
     require(msg.value == bamData.getMiningPrice(typeString), 'Not enough eth');
     importAddress.transfer(msg.value);
     uint time = now; 
     bamData.setBuyer(msg.sender, typeString, time, getSign(timeStamp));
     (,,,,uint id) = bamData.getMiningMachine(typeString);
     emit BuyMachine(msg.sender, typeString, msg.value, getSign(timeStamp), id);
  }
   function getRecordInfo (address buyerAddress, uint signId) public isHaveBuyer(buyerAddress) view returns(address buyAdress, string memory recordType, uint passTime, uint price, uint haveWithdrawal){
      return bamData.getBuyerRecord(buyerAddress,signId);
   }
   function getCanWithdrawal (uint signId, string memory typeString) public isHaveBuyer(msg.sender) view returns(uint withdrawalAmount, uint passtime) {
    (,, uint startTime,,uint haveWithdrawal) = bamData.getBuyerRecord(msg.sender, signId);
      uint havePasstime = (now - startTime)/86400;
      uint backmount;
      if(havePasstime<=365) {
        backmount = bamData.getMiningBackMount(typeString) * havePasstime;
      } else {
        backmount = bamData.getMiningBackMount(typeString) * 365;  
      }
     return ((backmount -  haveWithdrawal), havePasstime);
      
   }
  function Obtain (uint signId, string memory typeString) public isHaveBuyer(msg.sender) {
    (,string memory haveTypeString, uint startTime,,uint haveWithdrawal) = bamData.getBuyerRecord(msg.sender, signId);
       require(keccak256(abi.encodePacked(typeString)) == keccak256(abi.encodePacked(haveTypeString)), 'Wrong miner type');
      uint havePasstime =(now - startTime)/86400;
      uint backmount;
        if(havePasstime<=365) {
        backmount = bamData.getMiningBackMount(typeString) * havePasstime;
      } else {
        backmount = bamData.getMiningBackMount(typeString) * 365;  
      }
      require(backmount > haveWithdrawal,'This miner has been received');
      bamData.Obtain(signId, typeString, msg.sender, backmount - haveWithdrawal);
      bamData.setRecordHaveWithdrawal(msg.sender, signId, backmount -  haveWithdrawal);
      emit ObtainEvent(msg.sender,backmount -  haveWithdrawal, signId);
     }
  function SetDynamicGains (address toAddress,uint amount) public isOwner {
      bamData.SetDynamicGains(toAddress, bamData.getDynamicGain(toAddress) + amount);
      emit SetDynamicGainsEvent(toAddress, amount);
  }
  function getDynamicGain () public view returns (uint amount) {
     return bamData.getDynamicGain(msg.sender);
  }
  function obtainDynamicGains (uint amount) public {
    bamData.obtainDynamicGains(msg.sender, amount);
    bamData.SetDynamicGains(msg.sender, bamData.getDynamicGain(msg.sender) - amount);
    emit DynamicGainsEvent(msg.sender, amount, 'obtainDynamicGains');
  }
  function getSign (uint time) public view returns (uint256 signNum) {
    uint256 sign = uint256(keccak256(abi.encodePacked(
                    (block.timestamp),
                    (block.difficulty),
                    ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (time)),
                    (block.gaslimit),
                    ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (time)),
                    (block.number)
                ))) % 100000;
    return sign;
  }
  function setBuyer (address buyerAddress, string memory typeString, uint time, uint signId) public isOwner {
    bamData.setBuyer(buyerAddress, typeString, time, signId);
  }
  function setBuyerWithdrawal (address buyerAddress, uint amount, uint signId) public isOwner {
    bamData.setBuyerWithdrawal(buyerAddress, amount, signId);
  }
}

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