// SPDX-License: MIT
pragma solidity ^0.8.18;

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

import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract FIVLATAMCOIN is Initializable, ERC20Upgradeable, ERC20BurnableUpgradeable, OwnableUpgradeable, ReentrancyGuardUpgradeable {
    // ================= VARIABLES PRINCIPALES =================
    uint256 public constant INITIAL_SUPPLY = 100_000_000 * 10**18;
    uint256 public constant MAX_SUPPLY = 200_000_000 * 10**18;
    uint256 public constant MAX_BURN_RATE = 5; // 5%
    uint256 public constant MAX_REWARD_RATE = 20; // 20%
    uint256 public constant REWARD_SUPPLY_LIMIT = 10_000_000 * 10**18; // 10 millones para recompensas

    uint256 public burnRate; // % por transacción
    uint256 public stakingRewardRate; // % de recompensa por staking
    uint256 public totalStaked;
    mapping(address => uint256) public stakingBalance;
    mapping(address => uint256) public stakingTimestamp;

    // ================= GOVERNANCE =================
    struct Proposal {
        string description;
        uint256 votesFor;
        uint256 votesAgainst;
        uint256 deadline;
        bool executed;
        bool vetoed;
        mapping(address => bool) hasVoted;
    }
    
    Proposal[] public proposals;
    mapping(address => bool) public multiSigApprovers;
    mapping(uint256 => mapping(address => bool)) public hasVetoed;
    mapping(uint256 => uint256) public vetoVotes;
    uint256 public requiredSignatures;

    // ================= EXCLUSIÓN DE QUEMA =================
    mapping(address => bool) public exemptFromBurn;

    // ================= INICIALIZADOR =================
    function initialize(address[] memory _approvers, uint256 _requiredSignatures) public initializer {
        __ERC20_init("FIVLATAMCOIN", "FIV");
        __ERC20Burnable_init();
        __Ownable_init();
        __ReentrancyGuard_init();
        require(_requiredSignatures > 0 && _requiredSignatures <= _approvers.length, "Invalid signatures");

        for (uint256 i = 0; i < _approvers.length; i++) {
            multiSigApprovers[_approvers[i]] = true;
        }

        requiredSignatures = _requiredSignatures;
        _mint(msg.sender, INITIAL_SUPPLY);
        burnRate = 2; // 2% por defecto
        stakingRewardRate = 10; // 10% por defecto
    }

    // ================= TRANSFERENCIA CON QUEMA =================
    function setExemptFromBurn(address account, bool status) external onlyOwner {
        exemptFromBurn[account] = status;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal override {
        uint256 burnAmount = 0;
        if (!exemptFromBurn[sender]) {
            burnAmount = (amount * burnRate) / 100;
        }
        require(amount > burnAmount, "Burn amount exceeds transfer amount");
        super._burn(sender, burnAmount);
        super._transfer(sender, recipient, amount - burnAmount);
    }

    // ================= STAKING =================
    function stake(uint256 amount) external nonReentrant {
        require(amount > 0, "Cannot stake zero");
        _transfer(msg.sender, address(this), amount);
        stakingBalance[msg.sender] += amount;
        stakingTimestamp[msg.sender] = block.timestamp;
        totalStaked += amount;
        emit Staked(msg.sender, amount);
    }

    function unstake() external nonReentrant {
        uint256 staked = stakingBalance[msg.sender];
        require(staked > 0, "Nothing to unstake");
        uint256 duration = block.timestamp - stakingTimestamp[msg.sender];
        uint256 reward = (staked * stakingRewardRate * duration) / (365 days * 100);

        uint256 totalReward = totalSupply() + reward;
        require(totalReward <= MAX_SUPPLY + REWARD_SUPPLY_LIMIT, "Reward exceeds reward supply limit");

        stakingBalance[msg.sender] = 0;
        totalStaked -= staked;
        _mint(msg.sender, reward);
        _transfer(address(this), msg.sender, staked);
        emit Unstaked(msg.sender, staked);
        emit RewardClaimed(msg.sender, reward);
    }

    // ================= GOVERNANCE =================
    function createProposal(string calldata _description, uint256 _duration) external onlyOwner {
        Proposal storage p = proposals.push();
        p.description = _description;
        p.deadline = block.timestamp + _duration;
        emit ProposalCreated(proposals.length - 1, _description, p.deadline);
    }

    function vote(uint256 _proposalId, bool support) external {
        Proposal storage p = proposals[_proposalId];
        require(!p.hasVoted[msg.sender], "Already voted");
        require(block.timestamp < p.deadline, "Voting ended");

        p.hasVoted[msg.sender] = true;
        if (support) p.votesFor++;
        else p.votesAgainst++;
    }

    function executeProposal(uint256 _proposalId) external {
        Proposal storage p = proposals[_proposalId];
        require(block.timestamp >= p.deadline, "Voting not ended");
        require(!p.executed && !p.vetoed, "Already handled");
        require(p.votesFor > p.votesAgainst, "Not approved");

        p.executed = true;
        emit ProposalExecuted(_proposalId, true);
    }

    function vetoProposal(uint256 _proposalId) external {
        require(multiSigApprovers[msg.sender], "Not authorized");
        require(!hasVetoed[_proposalId][msg.sender], "Already vetoed");

        vetoVotes[_proposalId]++;
        hasVetoed[_proposalId][msg.sender] = true;
        if (vetoVotes[_proposalId] >= requiredSignatures) {
            proposals[_proposalId].vetoed = true;
        }
    }

    // ================= OWNER SETTERS =================
    function setBurnRate(uint256 _rate) external onlyOwner {
        require(_rate <= MAX_BURN_RATE, "Too high");
        burnRate = _rate;
    }

    function setStakingRewardRate(uint256 _rate) external onlyOwner {
        require(_rate <= MAX_REWARD_RATE, "Too high");
        stakingRewardRate = _rate;
    }

    function mint(address to, uint256 amount) external onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }

    // ================= EVENTS =================
    event ProposalCreated(uint256 proposalId, string description, uint256 deadline);
    event ProposalExecuted(uint256 proposalId, bool success);
    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount);
    event RewardClaimed(address indexed user, uint256 amount);
}