// SPDX-License-Identifier: UNLICENSED

pragma solidity =0.8.18;

import "@openzeppelin/contracts/utils/Context.sol";

import "./TemplateFactoryLibrary.sol";
import "./ITemplateFactory.sol";
import "./ITemplateDeployer.sol";

contract TemplateDeployer is ITemplateDeployer, Context {
    using TemplateFactoryLibrary for ITemplateFactory;

    /**
     * @inheritdoc ITemplateDeployer
     */
    address public immutable override FACTORY = address(TemplateFactoryLibrary.FACTORY);

    /**
     * @inheritdoc ITemplateDeployer
     */
    bytes32 public immutable override INIT_CODE_HASH;

    /**
     * @inheritdoc ITemplateDeployer
     */
    bytes32 public immutable override TEMPLATE;

    /**
     * @inheritdoc ITemplateDeployer
     */
    uint256 public immutable override TEMPLATE_VERSION;

    address[] private _deployments;

    constructor(bytes32 template, uint256 version) {
        TEMPLATE = template;
        TEMPLATE_VERSION = version;
        INIT_CODE_HASH = ITemplateFactory(FACTORY).initCodeHash(template, version, "");
    }

    // slither-disable-next-line external-function
    function deployment(uint256 index) public view override returns (address) {
        return _deployments[index];
    }

    /**
     * @inheritdoc ITemplateDeployer
     */
    function totalDeployments() public view override returns (uint256) {
        return _deployments.length;
    }

    /**
     * @inheritdoc ITemplateDeployer
     */
    // slither-disable-next-line external-function
    function deployed(address target) public view override returns (bool) {
        return deploymentInfo(target).sender == address(this);
    }

    /**
     * @inheritdoc ITemplateDeployer
     */
    function deploymentInfo(address target) public view override returns (ITemplateFactory.DeploymentInfo memory) {
        return ITemplateFactory(FACTORY).deploymentInfo(target);
    }

    function _predictDeployAddress(bytes memory args, bytes32 salt) internal view returns (address) {
        return ITemplateFactory(FACTORY).predictDeployAddress(TEMPLATE, TEMPLATE_VERSION, args, salt);
    }

    function _defaultSalt() internal virtual returns (bytes32) {
        return TemplateFactoryLibrary.defaultSalt(TEMPLATE, TEMPLATE_VERSION);
    }

    function _deploy(bytes32 salt) internal returns (address) {
        return _deploy("", salt);
    }

    function _deploy(bytes memory args) internal returns (address) {
        return _deploy(args, _defaultSalt());
    }

    function _deploy(bytes memory args, bytes32 salt) internal virtual returns (address _deployment) {
        _deployment = ITemplateFactory(FACTORY).deployTemplate(TEMPLATE, TEMPLATE_VERSION, args, salt);
        _deployments.push(_deployment);
        emit TemplateDeployed(_deployment, _msgSender());
    }
}