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

contract BillionaireLand {
    address public owner;
    uint256 public totalSupply;
    uint256 public launchTime;
    uint256 public initialSymbolLength = 5;
    uint256 public backingFactor = 1 ether; // The factor by which value is backed up

    struct Transaction {
        address from;
        address to;
        uint256 value;
        uint256 timestamp;
        bool verified;
    }

    struct Rune {
        string symbol;
        address runeOwner;
        uint256 timestamp;
    }

    mapping(bytes32 => Transaction) public transactions;
    mapping(string => Rune) public runes;
    mapping(address => uint256) public balances;

    event TransactionInitiated(address indexed from, address indexed to, uint256 value, bytes32 txHash);
    event TransactionVerified(bytes32 indexed txHash, uint256 valueBackedUp);
    event ValueBackedUp(bytes32 indexed txHash, uint256 valueBackedUp);
    event RuneAssigned(string indexed symbol, address indexed runeOwner);
    event RuneTransferred(string indexed symbol, address indexed oldOwner, address indexed newOwner);
    event RuneBurned(string indexed symbol);

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    constructor() {
        owner = msg.sender;
        launchTime = block.timestamp;
        totalSupply = 1000000 * 1 ether; // Initial supply
        balances[owner] = totalSupply;
    }

    function getSymbolLength() public view returns (uint256) {
        uint256 yearsPassed = (block.timestamp - launchTime) / 365 days;
        if (yearsPassed > 2) {
            return 3;
        }
        return initialSymbolLength - yearsPassed;
    }

    // Assign a rune symbol to a user
    function assignRune(string memory _symbol) public {
        require(bytes(_symbol).length >= getSymbolLength(), "Symbol too short");
        require(runes[_symbol].runeOwner == address(0), "Symbol already taken");

        runes[_symbol] = Rune({
            symbol: _symbol,
            runeOwner: msg.sender,
            timestamp: block.timestamp
        });

        emit RuneAssigned(_symbol, msg.sender);
    }

    // Transfer rune ownership
    function transferRune(string memory _symbol, address _newOwner) public {
        require(runes[_symbol].runeOwner == msg.sender, "Not the rune owner");

        runes[_symbol].runeOwner = _newOwner;

        emit RuneTransferred(_symbol, msg.sender, _newOwner);
    }

    // Burn a rune (remove it from circulation)
    function burnRune(string memory _symbol) public {
        require(runes[_symbol].runeOwner == msg.sender, "Not the rune owner");

        delete runes[_symbol];

        emit RuneBurned(_symbol);
    }

    // Initiate a transaction
    function initiateTransaction(address _to, uint256 _value) public returns (bytes32) {
        require(balances[msg.sender] >= _value, "Insufficient balance");

        bytes32 txHash = keccak256(abi.encodePacked(msg.sender, _to, _value, block.timestamp));
        transactions[txHash] = Transaction(msg.sender, _to, _value, block.timestamp, false);

        balances[msg.sender] -= _value;

        emit TransactionInitiated(msg.sender, _to, _value, txHash);

        return txHash;
    }

    // Verify a transaction (Proof of Work simulation)
    function verifyTransaction(bytes32 _txHash) public onlyOwner {
        Transaction storage txn = transactions[_txHash];
        require(txn.value > 0, "Transaction not found or already verified");

        txn.verified = true;
        balances[txn.to] += txn.value;

        emit TransactionVerified(_txHash, txn.value);
    }

    // Ensure built-in liquidity (Proof of Power)
    function backUpValue(bytes32 _txHash) public onlyOwner {
        Transaction storage txn = transactions[_txHash];
        require(txn.verified, "Transaction not verified");

        uint256 valueToBackUp = txn.value * backingFactor;
        require(balances[owner] >= valueToBackUp, "Insufficient backing balance");

        // Simulate value backup by adding to owner's balance
        balances[owner] += valueToBackUp;

        emit ValueBackedUp(_txHash, valueToBackUp);
    }

    // Check balance
    function getBalance(address _address) public view returns (uint256) {
        return balances[_address];
    }
}