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

/**
 * @title DanteToken
 * @dev ERC-20 compatible token with supply cap, minting, burning, and ownership control.
 */
contract DanteToken {
    // Public state variables
    string public projectWebsite; // Reference to the official website of the project.

    // Internal state variables
    mapping(address => uint256) private _balances; // Tracks balances of token holders.
    mapping(address => mapping(address => uint256)) private _allowances; // Tracks allowances for delegated transfers.

    address private _owner; // Owner of the contract.
    uint256 private _totalSupply; // Tracks the total token supply.
    uint256 private immutable _cap; // Maximum supply cap.

    string private _name; // Name of the token.
    string private _symbol; // Symbol of the token.

    /**
     * @dev Initializes the contract with token details and mints the initial supply to the owner.
     * @param tokenName The name of the token.
     * @param tokenSymbol The symbol of the token.
     * @param initialSupply The initial supply of tokens (in units without decimals).
     * @param website The project website URL.
     */
    constructor(string memory tokenName, string memory tokenSymbol, uint256 initialSupply, string memory website) {
        _name = tokenName;
        _symbol = tokenSymbol;
        _cap = initialSupply * 10 ** decimals();
        projectWebsite = website;
        _owner = msg.sender;
        _mint(msg.sender, _cap);
    }

    /**
     * @dev Emitted when tokens are transferred from one account to another.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when a spender's allowance is updated.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Emitted when ownership is transferred to a new address.
     */
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Transfers tokens to a specified address.
     * @param to The recipient address.
     * @param value The amount of tokens to transfer.
     * @return Boolean indicating success.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        address owner = msg.sender;
        require(to != address(0), "Transfer to the zero address");
        require(_balances[owner] >= value, "Insufficient balance");
        _balances[owner] -= value;
        _balances[to] += value;
        emit Transfer(owner, to, value);
        return true;
    }

    /**
     * @dev Returns the allowance for a spender on an owner's tokens.
     * @param owner The owner of the tokens.
     * @param spender The spender.
     * @return The remaining allowance.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev Approves a spender to transfer tokens on the caller's behalf.
     * @param spender The address to approve.
     * @param value The allowance amount.
     * @return Boolean indicating success.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        address owner = msg.sender;
        _allowances[owner][spender] = value;
        emit Approval(owner, spender, value);
        return true;
    }

    /**
     * @dev Transfers tokens from one account to another, deducting from the caller's allowance.
     * @param from The sender's address.
     * @param to The recipient's address.
     * @param value The amount to transfer.
     * @return Boolean indicating success.
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= value, "Insufficient allowance");
        require(from != address(0), "Transfer from the zero address");
        require(to != address(0), "Transfer to the zero address");
        require(_balances[from] >= value, "Insufficient balance");

        _allowances[from][msg.sender] = currentAllowance - value;

        _balances[from] -= value;
        _balances[to] += value;

        emit Transfer(from, to, value);
        return true;
    }

    /**
     * @dev Increases the allowance for a spender.
     * @param spender The address to increase the allowance for.
     * @param addedValue The amount to add to the allowance.
     * @return Boolean indicating success.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _allowances[msg.sender][spender] += addedValue;
        emit Approval(msg.sender, spender, _allowances[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Decreases the allowance for a spender.
     * @param spender The address to decrease the allowance for.
     * @param subtractedValue The amount to subtract from the allowance.
     * @return Boolean indicating success.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(currentAllowance >= subtractedValue, "Allowance below zero");
        _allowances[msg.sender][spender] = currentAllowance - subtractedValue;
        emit Approval(msg.sender, spender, _allowances[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Burns tokens from the caller's balance, reducing the total supply.
     * @param value The amount of tokens to burn.
     */
    function burn(uint256 value) public {
        _balances[msg.sender] -= value;
        _totalSupply -= value;
        emit Transfer(msg.sender, address(0), value);
    }

    /**
     * @dev Updates the project website URL.
     * @param newWebsite The new website URL.
     */
    function updateWebsite(string memory newWebsite) public onlyOwner {
        projectWebsite = newWebsite;
    }

    /**
     * @dev Modifier to restrict functions to the owner.
     */
    modifier onlyOwner() {
        require(msg.sender == _owner, "Caller is not the owner");
        _;
    }

    /**
     * @dev Transfers ownership of the contract to a new address.
     * @param newOwner The new owner's address.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Invalid new owner");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    /**
     * @dev Returns the name of the token.
     * @return The token name.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token.
     * @return The token symbol.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used for display purposes.
     * @return The number of decimals.
     */
    function decimals() public pure returns (uint8) {
        return 18;
    }

    /**
     * @dev Returns the total token supply.
     * @return The total supply.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Returns the token balance of an account.
     * @param account The account to query.
     * @return The balance of the account.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev Internal function to mint new tokens.
     * @param account The recipient of the minted tokens.
     * @param value The amount of tokens to mint.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0), "Mint to zero address");
        require(_totalSupply + value <= _cap, "Exceeds cap");

        _totalSupply += value;
        _balances[account] += value;
        emit Transfer(address(0), account, value);
    }
}

{
  "compilationTarget": {
    "DanteToken.sol": "DanteToken"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}