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

contract EnergyLabsAlphaPass {
    // Configuration - matches your requirements
    uint256 public constant MAX_SUPPLY = 4999;
    uint256 public constant PRICE = 0.0013 ether;
    uint256 public constant MAX_PER_WALLET = 5;
    
    // State variables - optimized for gas
    bool public mintEnabled;
    address public immutable contractOwner;
    uint256 private _currentId = 1;
    
    // Storage - packed for efficiency
    mapping(uint256 => address) private _owners;
    mapping(address => uint256) private _balances;

    // Metadata - using your exact URLs (constants don't use storage)
    string private constant BASE_URI = "https://mint-alpha-nft.defienergylabs.com/metadata/";
    string private constant IMAGE_URI = "https://mint-alpha-nft.defienergylabs.com/images/";

    // Events
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Minted(address indexed to, uint256 quantity);

    constructor() {
        contractOwner = msg.sender;
        mintEnabled = true;
    }

    // Main mint function with gas optimizations
    function mint(uint256 quantity) external payable {
        require(mintEnabled, "Minting disabled");
        require(_currentId + quantity - 1 <= MAX_SUPPLY, "Exceeds supply");
        require(_balances[msg.sender] + quantity <= MAX_PER_WALLET, "Wallet limit");
        require(msg.value >= PRICE * quantity, "Incorrect ETH");

        uint256 current = _currentId;
        address sender = msg.sender;
        uint256 newBalance = _balances[sender] + quantity;

        for (uint256 i = 0; i < quantity; i++) {
            _owners[current + i] = sender;
            emit Transfer(address(0), sender, current + i);
        }
        
        _currentId += quantity;
        _balances[sender] = newBalance;
        
        // More gas-efficient transfer
        (bool success, ) = contractOwner.call{value: msg.value}("");
        require(success, "ETH transfer failed");
        
        emit Minted(sender, quantity);
    }

    // Admin functions
    function toggleMint() external onlyOwner {
        mintEnabled = !mintEnabled;
    }

    // ERC721-like view functions for OpenSea compatibility
    function balanceOf(address owner) external view returns (uint256) {
        require(owner != address(0), "Zero address");
        return _balances[owner];
    }

    function ownerOf(uint256 tokenId) external view returns (address) {
        require(_exists(tokenId), "Nonexistent token");
        return _owners[tokenId];
    }

    function tokenURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId), "Nonexistent token");
        return string(abi.encodePacked(BASE_URI, _toString(tokenId), ".json"));
    }

    // Additional function for image display
    function imageURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId), "Nonexistent token");
        return string(abi.encodePacked(IMAGE_URI, _toString(tokenId), ".png"));
    }

    function totalSupply() external view returns (uint256) {
        return _currentId - 1;
    }

    // Internal helpers
    function _exists(uint256 tokenId) internal view returns (bool) {
        return tokenId < _currentId && tokenId != 0;
    }

    // Optimized number to string conversion
    function _toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) return "0";
        
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits--;
            buffer[digits] = bytes1(uint8(48 + value % 10));
            value /= 10;
        }
        return string(buffer);
    }

    modifier onlyOwner() {
        require(msg.sender == contractOwner, "Unauthorized");
        _;
    }
}

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