pragma solidity >=0.4.21 <0.9.0;
pragma experimental ABIEncoderV2;

import "./CJT.sol";

contract myToken is CJT {
    
    constructor() public {
        //CMJ Token specs
        symbol = "MYT";
        name = "My Token";
        decimals = 18;
        _totalSupply = 23*10**18;  //initial supply of 23 tokens
        _maxSupply = 23000000*10**18;   //Supply max is 2.3M
        balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }
    
}

contract myVault {
    string ipfsHash;
    string[] public allHashes;
     
    uint private init_reward;
    uint constant private mult = 10**18;
    uint constant private BurnRate = 990000107308170000;
    string constant private ipfsPre = "https://ipfs.io/ipfs/";
    uint private reward;
    
    struct Data {
        string hash;
        address user;
        uint reward;
        uint vaultNum; 
        string hLink;
    }
    
     mapping (string => Data) dataIds;
     myToken token;
    
    constructor() public {
        //Vault variables
        init_reward = 23000 * mult;
       
        reward = init_reward;
     }
     //Events
     event hashSent(uint _reward);
     event tokenMint(uint reward);
    
     function sendHash(string memory x) public payable {
        require(msg.value == 0.005 ether);
        ipfsHash = x;
       
        uint Reward = addHash(x);
        
        emit hashSent(Reward);
     }
     
     function validateHash(string memory x, address _to) public payable {
         require(msg.value == 0.001 ether);
         require(_to == dataIds[x].user);
         uint userbal;
         address addr = _to;
         
         
        uint _reward = dataIds[x].reward;
        token.mintTo(addr, _reward);
         
         userbal = token.balanceOf(addr);
         emit tokenMint(userbal);
    
     }
    
    function addHash(string memory x) internal returns (uint) {
        
        uint userReward;
        uint vNum;
        string memory _hLink;
        
        allHashes.push(x); //Save to allHashes
        
        userReward = rewardCal();  //calculate reward
        
        vNum = allHashes.length;    //Get vault num
        
        _hLink = append(x);         //get ipfs link
        
        dataIds[x] = Data({
              hash: x,
              user: msg.sender,
              reward: userReward,
              vaultNum: vNum,
              hLink: _hLink
          });
          
    
       return dataIds[x].reward;   
    }
    
     function getAllHashes() public view returns (string[] memory) {
        
         return allHashes;
    }
    
     function getCount() public view returns (uint) {
        return allHashes.length;
    }
    
  
    function rewardCal() private returns (uint) {
       uint _reward;
       
        if(allHashes.length > 0){
            
            reward = (reward / mult) * BurnRate;
            _reward = reward;
            
        }else{
             _reward = reward;
        }   
        
        return _reward;
    }
    
    function mintToken(string memory x, address y) public {
        address addr = y;
        
        uint _reward = dataIds[x].reward;
        token.mintTo(addr, _reward);
        
        
    }
    
    function append(string memory _hash) internal pure returns (string memory) {
    
        return string(abi.encodePacked(ipfsPre, _hash));
    
    }
    
}