pragma solidity ^0.5.6;


contract Auth {

    enum Op { NONE, EQ, NEQ, GT, LT, GTE, LTE, RET, NOT, AND, OR, XOR, IF_ELSE }

    bytes32 paramHash;
    mapping (bytes32 => bytes32) public permissions; // permissions hash => params hash
    mapping (bytes32 => Param[]) public permissionParams; // params hash => params

    uint256[] public params;

    struct Param {
        uint8 id;
        uint8 op;
        uint240 value; // even though value is an uint240 it can store addresses
        // in the case of 32 byte hashes losing 2 bytes precision isn't a huge deal
        // op and id take less than 1 byte each so it can be kept in 1 sstore
    }

    function createParam() public returns (uint256[] memory) {
        params = new uint256[](3);
        params[0] = uint8(205);
        params[1] = uint8(1);
        params[2] = uint240(50);
        return params;
        Param memory p = Param(1, 6, 300);
        //return uint256(p);
        //return uint240(50);
        //return uint256(uint8(205));
        //return uint256(uint8(1) & uint8(6) & uint240(300));

    }

    function toUint240(uint256 a) public pure returns (uint240) {
        return uint240(a);
    }


    function getOp() public pure returns (uint8) {
        return uint8(Op.EQ);
    }

    function createAndDecodeParam() pure public returns (uint8, uint8, uint240) {
        uint256 param;
        uint8 id = uint8(1);
        uint8 op = uint8(6);
        uint240 v = uint240(300);


        param = uint256(id) << 248 | uint256(op) << 240 | v;

        return decodeParam(param);
    }

    function decodeParam(uint256 encodedParam) pure public returns (uint8, uint8, uint240) {
        Param memory param = Param(decodeParamId(encodedParam), decodeParamOp(encodedParam), uint240(encodedParam));
        return (param.id, param.op, param.value);
    }

    function _saveParams(uint256[] memory _encodedParams) public returns (bytes32) {
        paramHash = keccak256(abi.encodePacked(_encodedParams));
        Param[] storage params = permissionParams[paramHash];

        if (params.length == 0) { // params not saved before
            for (uint256 i = 0; i < _encodedParams.length; i++) {
                uint256 encodedParam = _encodedParams[i];
                Param memory param = Param(decodeParamId(encodedParam), decodeParamOp(encodedParam), uint240(encodedParam));
                params.push(param);
            }
        }

        return paramHash;
    }

    function decodeParamOp(uint256 _x) public pure returns (uint8 b) {
        return uint8(_x >> (8 * 30));
    }

    function decodeParamId(uint256 _x) public pure returns (uint8 b) {
        return uint8(_x >> (8 * 31));
    }

    function decodeParamsList(uint256 _x) public pure returns (uint32 a, uint32 b, uint32 c) {
        a = uint32(_x);
        b = uint32(_x >> (8 * 4));
        c = uint32(_x >> (8 * 8));
    }


}