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

import {SafeProxyFactory} from "@safe-global/safe-contracts/contracts/proxies/SafeProxyFactory.sol";
import {SafeProxy} from "@safe-global/safe-contracts/contracts/proxies/SafeProxy.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

contract SAFEDeployer is Ownable {
    address public safeProxyFactory;
    address public modulesLib;
    address public fallbackModule;
    address public safeSingleton;

    mapping(address => uint256) public userAmounts;

    address[] public modules;
    address[] public users;

    address[] public ownersList;

    event SafeProxyDeploy(address indexed user, uint256 counter);
    event Initialiser(bytes data);
    event SafeProxyDeployed(address indexed user, address indexed proxy);

    constructor(
        address _safeProxyFactory,
        address[] memory _modules,
        address _modulesLib,
        address _fallbackModule,
        address _safeSingleton
    ) {
        safeProxyFactory = _safeProxyFactory;
        modules = _modules;
        modulesLib = _modulesLib;
        fallbackModule = _fallbackModule;
        safeSingleton = _safeSingleton;
    }

    // Receive function to accept ETHs
    receive() external payable {
        users.push(msg.sender);
        userAmounts[msg.sender] += msg.value;
        emit SafeProxyDeploy(address(msg.sender), users.length);
    }

    // Receive function to accept ETH
    fallback() external payable {
        users.push(msg.sender);
        userAmounts[msg.sender] += msg.value;
        emit SafeProxyDeploy(msg.sender, users.length);
    }

    function deploySafe(address owner, uint256 nonce) public {
        SafeProxyFactory gnosisSafe = SafeProxyFactory(safeProxyFactory);
        delete ownersList;
        ownersList.push(owner);
        bytes memory initializer = abi.encodeWithSignature(
            "setup(address[],uint256,address,bytes,address,address,uint256,address)",
            ownersList,
            1,
            modulesLib,
            abi.encodeWithSignature("enableModules(address[])", modules),
            fallbackModule,
            address(0),
            0,
            address(0)
        );

        SafeProxy proxy = gnosisSafe.createProxyWithNonce(
            safeSingleton,
            initializer,
            nonce
        );
        delete (ownersList);
        emit SafeProxyDeployed(owner, address(proxy));
    }

    function deploySafeProxy(uint256 counter) external {
        address user = users[counter];
        require(user != address(0), "no such user");
        deploySafe(user, counter + block.timestamp);
    }

    function updateSafeProxyFactory(
        address _safeProxyFactory
    ) external onlyOwner {
        safeProxyFactory = _safeProxyFactory;
    }

    function updateModulesList(
        address[] memory _modulesList
    ) external onlyOwner {
        modules = _modulesList;
    }

    function updateModulesLib(address _modulesLib) external onlyOwner {
        modulesLib = _modulesLib;
    }

    function updateFallbackModule(address _fallbackModule) external onlyOwner {
        fallbackModule = _fallbackModule;
    }

    function updateSafeSingleton(address _safeSingleton) external onlyOwner {
        safeSingleton = _safeSingleton;
    }
}