// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {ERC1155} from "../../lib/ERC1155.sol";
import {ERC1155Holder} from "../../lib/ERC1155Holder.sol" ;
import { Create2 } from "../../lib/Create2.sol";
import { FxBaseRootTunnel } from "../../tunnel/FxBaseRootTunnel.sol";

contract FxERC1155RootTunnel is FxBaseRootTunnel, Create2, ERC1155Holder {
    bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
    bytes32 public constant DEPOSIT_BATCH = keccak256("DEPOSIT_BATCH");
    bytes32 public constant WITHDRAW = keccak256("WITHDRAW");
    bytes32 public constant WITHDRAW_BATCH = keccak256("WITHDRAW_BATCH");
    bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
    
    event TokenMappedERC1155(address indexed rootToken, address indexed childToken);
    event FxWithdrawERC1155(address indexed rootToken, address indexed childToken, address indexed userAddress, uint256 id, uint256 amount);
    event FxDepositERC1155(address indexed rootToken, address indexed depositor, address indexed userAddress, uint256 id, uint256 amount);
    event FxWithdrawBatchERC1155(address indexed rootToken, address indexed childToken, address indexed userAddress, uint256[] ids, uint256[] amounts);
    event FxDepositBatchERC1155(address indexed rootToken, address indexed userAddress, uint256[] ids, uint256[] amounts);

    mapping(address => address) public rootToChildTokens;
    bytes32 public childTokenTemplateCodeHash;
    
    constructor(address _checkpointManager, address _fxRoot, address _fxERC1155Token) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
        childTokenTemplateCodeHash = keccak256(minimalProxyCreationCode(_fxERC1155Token));
    }
    
    function mapToken(address rootToken) public {
        require(rootToChildTokens[rootToken] == address(0x0), "FxERC1155RootTunnel: ALREADY_MAPPED");

        ERC1155 rootTokenContract = ERC1155(rootToken);
        string memory uri = rootTokenContract.uri(0); //token Id?

        // MAP_TOKEN, encode(rootToken,uri)
        bytes memory message = abi.encode(MAP_TOKEN, abi.encode(rootToken,uri));
        _sendMessageToChild(message);

        // compute child token address before deployment using create2
        bytes32 salt = keccak256(abi.encodePacked(rootToken));
        address childToken = computedCreate2Address(salt, childTokenTemplateCodeHash, fxChildTunnel);

        // add into mapped tokens
        rootToChildTokens[rootToken] = childToken;
         emit TokenMappedERC1155(rootToken, childToken);
    }
    
    function deposit(address rootToken, address user, uint256 id, uint256 amount, bytes memory data) public {
        // map token if not mapped
        if (rootToChildTokens[rootToken] == address(0x0)) {
            mapToken(rootToken);
        }

        // transfer from depositor to this contract
        ERC1155(rootToken).safeTransferFrom(
            msg.sender,    // depositor
            address(this), // manager contract
            id,
            amount,
            data
        );

        // DEPOSIT, encode(rootToken, depositor, user, id, amount, extra data)
        bytes memory message = abi.encode(DEPOSIT, abi.encode(rootToken, msg.sender, user, id, amount, data));
        _sendMessageToChild(message);
        emit FxDepositERC1155(rootToken, msg.sender, user, id, amount);
    }
    
    function depositBatch(address rootToken, address user, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public {
        // map token if not mapped
        if (rootToChildTokens[rootToken] == address(0x0)) {
            mapToken(rootToken);
        }

        // transfer from depositor to this contract
        ERC1155(rootToken).safeBatchTransferFrom(
            msg.sender,    // depositor
            address(this), // manager contract
            ids,
            amounts,
            data
        );

        // DEPOSIT_BATCH, encode(rootToken, depositor, user, id, amount, extra data)
        bytes memory message = abi.encode(DEPOSIT_BATCH, abi.encode(rootToken, msg.sender, user, ids, amounts, data));
        _sendMessageToChild(message);
        emit FxDepositBatchERC1155(rootToken, user, ids, amounts);
    }
    
    function _processMessageFromChild(bytes memory data) internal override {
        (bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
        
        if(syncType == WITHDRAW) {
            _syncWithdraw(syncData);
        }
         
        else if(syncType == WITHDRAW_BATCH) {
            _syncBatchWithdraw(syncData);
        }
        
        else {
            revert("FxERC1155RootTunnel: INVALID_SYNC_TYPE");
        }
            
    }
    
    function _syncWithdraw(bytes memory syncData) internal {
        (address rootToken, address childToken, address user, uint256 id, uint256 amount, bytes memory data) = abi.decode(syncData, (address, address, address, uint256, uint256, bytes));
        require(rootToChildTokens[rootToken] == childToken, "FxERC1155RootTunnel: INVALID_MAPPING_ON_EXIT");
        ERC1155(rootToken).safeTransferFrom(address(this), user, id, amount, data);
        emit FxWithdrawERC1155(rootToken, childToken, user, id, amount);
    }
    
    function _syncBatchWithdraw(bytes memory syncData) internal {
        (address rootToken, address childToken, address user, uint256[] memory ids, uint256[] memory amounts, bytes memory data) = abi.decode(syncData, (address, address, address, uint256[], uint256[], bytes));
        require(rootToChildTokens[rootToken] == childToken, "FxERC1155RootTunnel: INVALID_MAPPING_ON_EXIT");
        ERC1155(rootToken).safeBatchTransferFrom(address(this), user, ids, amounts, data);
        emit FxWithdrawBatchERC1155(rootToken, childToken, user, ids, amounts);
    }
}