// Stake NZT + ETH for enhanced reputation
const agentsContract = new ethers.Contract(
  agentsAddress,
  agentsAbi,
  signer
);

// Prepare multi-asset stake
const assets = [
  nztTokenAddress,
  ethers.ZeroAddress  // ETH represented as zero address
];

const amounts = [
  ethers.parseEther("5000"),  // 5,000 NZT
  ethers.parseEther("2")      // 2 ETH
];

// Approve NZT spending
const nztContract = new ethers.Contract(nztTokenAddress, erc20Abi, signer);
await nztContract.approve(agentsAddress, amounts[0]);

// Stake both assets
const stakeTx = await agentsContract.stakeMultiAsset(assets, amounts, {
  value: amounts[1]  // Send ETH value
});

await stakeTx.wait();

// Calculate effective stake
// Effective = 5,000 NZT + (2 ETH × 2,000) = 9,000 NZT equivalent

function calculateEffectiveStake(
    address[] memory assets,
    uint256[] memory amounts
) public view returns (uint256) {
    uint256 effectiveStake = 0;

    for (uint256 i = 0; i < assets.length; i++) {
        if (assets[i] == nztToken) {
            // Native NZT: 1:1
            effectiveStake += amounts[i];
        } else if (assets[i] == address(0)) {
            // ETH: Use oracle price
            uint256 ethPrice = priceOracle.getPrice(ETH_USD);
            uint256 nztPrice = priceOracle.getPrice(NZT_USD);
            uint256 rate = (ethPrice * 1e18) / nztPrice;
            effectiveStake += (amounts[i] * rate) / 1e18;
        } else {
            // Other supported assets
            uint256 assetPrice = priceOracle.getPrice(assets[i]);
            uint256 nztPrice = priceOracle.getPrice(NZT_USD);
            uint256 rate = (assetPrice * 1e18) / nztPrice;
            effectiveStake += (amounts[i] * rate) / 1e18;
        }
    }

    return effectiveStake;
}

function calculateStakingAPY(
  totalStaked,
  dailyFeeRevenue,
  annualEmission,
  annualSlashing
) {
  // Annual fee rewards (35% of fees to stakers)
  const annualFees = dailyFeeRevenue * 365 * 0.35;

  // Slashing distribution (30% to stakers)
  const slashingRewards = annualSlashing * 0.30;

  // Emission to stakers (40% of total emissions)
  const emissionRewards = annualEmission * 0.40;

  // Total annual rewards
  const totalRewards = annualFees + slashingRewards + emissionRewards;

  // APY calculation
  const apy = (totalRewards / totalStaked) * 100;

  return {
    totalRewards,
    apy,
    breakdown: {
      fees: annualFees,
      emissions: emissionRewards,
      slashing: slashingRewards
    }
  };
}

// Example: Year 2 projections
const result = calculateStakingAPY(
  300_000_000,   // 300M NZT staked (30% of supply)
  100_000,       // 100k NZT daily fees
  100_000_000,   // 100M NZT annual emission
  5_000_000      // 5M NZT annual slashing
);

console.log(`Staking APY: ${result.apy.toFixed(2)}%`);
console.log(`Total Rewards: ${result.totalRewards.toLocaleString()} NZT`);
console.log(`From Fees: ${result.breakdown.fees.toLocaleString()} NZT`);
console.log(`From Emissions: ${result.breakdown.emissions.toLocaleString()} NZT`);
console.log(`From Slashing: ${result.breakdown.slashing.toLocaleString()} NZT`);

// Output:
// Staking APY: 10.08%
// Total Rewards: 30,232,500 NZT
// From Fees: 12,775,000 NZT
// From Emissions: 40,000,000 NZT (Note: this is 40% of 100M, not 100M directly)
// From Slashing: 1,500,000 NZT

// Auto-compound staking rewards
async function compoundRewards() {
  const stakingContract = new ethers.Contract(
    stakingAddress,
    stakingAbi,
    signer
  );

  // Check pending rewards
  const pending = await stakingContract.pendingRewards(userAddress);

  if (pending > 0) {
    // Claim rewards
    const claimTx = await stakingContract.claimRewards();
    await claimTx.wait();

    // Approve and re-stake
    const nztContract = new ethers.Contract(nztAddress, erc20Abi, signer);
    await nztContract.approve(stakingAddress, pending);

    const stakeTx = await stakingContract.stake(pending);
    await stakeTx.wait();

    console.log(`Compounded ${ethers.formatEther(pending)} NZT`);
  }
}

// Auto-compound weekly
setInterval(compoundRewards, 7 * 24 * 60 * 60 * 1000); // Every 7 days

// Initiate unbonding
const stakingContract = new ethers.Contract(stakingAddress, stakingAbi, signer);

const unbondTx = await stakingContract.startUnbonding();
await unbondTx.wait();

console.log("Unbonding started, wait 7 days");

// Check unbonding status
const stake = await stakingContract.stakes(userAddress);
const unbondingEnd = new Date(stake.unbondingEnd * 1000);
console.log(`Can withdraw after: ${unbondingEnd.toLocaleString()}`);

// After 7 days
const withdrawTx = await stakingContract.unstake();
await withdrawTx.wait();
console.log("Stake withdrawn");

// Early exit (5% penalty)
const earlyExitTx = await stakingContract.earlyExit();
await earlyExitTx.wait();

// User receives 95% immediately
// 5% penalty goes to treasury

/// @notice Unstake partial amount
function unstakePartial(uint256 amount) external nonReentrant {
    Stake storage userStake = stakes[msg.sender];
    require(userStake.amount >= amount, "Insufficient stake");
    require(userStake.amount - amount >= minStake || amount == userStake.amount, "Below minimum");

    _updateRewards(msg.sender);

    userStake.amount -= amount;
    userStake.rewardDebt = userStake.amount * rewardConfig.accRewardPerShare / 1e18;

    rewardConfig.totalStaked -= amount;

    nztToken.transfer(msg.sender, amount);

    emit UnstakedPartial(msg.sender, amount);
}

contract SlashingInsurance {
    struct Policy {
        uint256 coverage;      // Max coverage amount
        uint256 premium;       // Monthly premium
        uint256 expiry;        // Policy expiration
        bool active;
    }

    mapping(address => Policy) public policies;

    /// @notice Purchase slashing insurance
    function buyInsurance(uint256 coverage, uint256 duration) external payable {
        uint256 premium = calculatePremium(coverage, duration);
        require(msg.value >= premium, "Insufficient premium");

        policies[msg.sender] = Policy({
            coverage: coverage,
            premium: premium,
            expiry: block.timestamp + duration,
            active: true
        });

        emit InsurancePurchased(msg.sender, coverage, duration);
    }

    /// @notice Claim insurance after slashing
    function claimInsurance(uint256 slashedAmount) external {
        Policy storage policy = policies[msg.sender];
        require(policy.active, "No active policy");
        require(block.timestamp < policy.expiry, "Policy expired");

        uint256 payout = min(slashedAmount, policy.coverage);

        // Transfer payout
        nztToken.transfer(msg.sender, payout);

        // Reduce coverage or cancel policy
        if (payout >= policy.coverage) {
            policy.active = false;
        } else {
            policy.coverage -= payout;
        }

        emit InsuranceClaimed(msg.sender, payout);
    }

    function calculatePremium(uint256 coverage, uint256 duration) public pure returns (uint256) {
        // Base rate: 1% of coverage per month
        uint256 monthlyRate = coverage / 100;
        uint256 months = duration / 30 days;
        return monthlyRate * months;
    }
}

function calculateReputation(agent) {
  const stats = getAgentStats(agent);

  // Base scores (out of 250 each)
  const reliabilityScore = (stats.completedTasks / (stats.completedTasks + stats.failedTasks)) * 250;
  const accuracyScore = (stats.attestedCorrect / stats.totalAttestations) * 250;
  const performanceScore = stats.avgResponseTime < 60 ? 250 : 250 * 60 / stats.avgResponseTime;

  // Trustworthiness based on stake (out of 250)
  const stakeScore = min((stats.effectiveStake / 1000) * 125, 125); // Max at 1000 NZT
  const timeScore = (Date.now() - stats.registrationTime) > 30_DAYS ? 125 : 0;
  const trustScore = stakeScore + timeScore;

  // Apply slashing penalty
  const rawScore = reliabilityScore + accuracyScore + performanceScore + trustScore;
  const slashPenalty = (rawScore * stats.slashCount * 10) / 100; // -10% per slash

  return max(rawScore - slashPenalty, 0);
}

// Maximize reputation through strategic staking
function optimizeReputation(currentStake, targetReputation) {
  const calculations = {
    // Stake more to boost trust score
    additionalStakeNeeded: max(0, targetReputation * 4 - currentStake),

    // Time-based boost (can't be rushed)
    daysUntilTimeBoost: 30 - daysSinceRegistration,

    // Performance improvements needed
    targetCompletionRate: targetReputation / 1000 * 0.95,
    targetAccuracy: targetReputation / 1000 * 0.98,

    // Current score breakdown
    currentBreakdown: calculateReputation(agent)
  };

  return calculations;
}

const agentsContract = new ethers.Contract(agentsAddress, agentsAbi, signer);

// Approve NZT spending
const nztContract = new ethers.Contract(nztAddress, erc20Abi, signer);
await nztContract.approve(agentsAddress, delegationAmount);

// Delegate to agent
const delegateTx = await agentsContract.delegateStake(
  agentAddress,
  ethers.parseEther("10000"),  // 10,000 NZT
  9000  // 90% commission (delegator receives 90%, agent keeps 10%)
);

await delegateTx.wait();

console.log("Delegated 10,000 NZT to agent");

// Check delegation
const delegation = await agentsContract.delegations(userAddress, agentAddress);
console.log(`Delegated: ${ethers.formatEther(delegation.amount)} NZT`);
console.log(`Commission: ${delegation.commission / 100}%`);

// Claim delegation rewards
const claimTx = await agentsContract.claimDelegationRewards(agentAddress);
await claimTx.wait();

contract AgentDelegation {
    struct Delegation {
        uint256 amount;
        uint256 commission;  // Basis points (9000 = 90%)
        uint256 rewardDebt;
        uint256 unbondingEnd;
        bool unbonding;
    }

    mapping(address => mapping(address => Delegation)) public delegations;
    mapping(address => uint256) public totalDelegated;

    /// @notice Delegate stake to agent
    function delegateStake(
        address agent,
        uint256 amount,
        uint256 commission
    ) external {
        require(commission <= 10000, "Invalid commission");
        require(commission >= 7000, "Min 70% for delegator");

        nztToken.transferFrom(msg.sender, address(this), amount);

        Delegation storage del = delegations[msg.sender][agent];
        del.amount += amount;
        del.commission = commission;

        totalDelegated[agent] += amount;

        // Update agent's effective stake
        _updateAgentStake(agent);

        emit Delegated(msg.sender, agent, amount, commission);
    }

    /// @notice Undelegate stake
    function undelegate(address agent) external {
        Delegation storage del = delegations[msg.sender][agent];
        require(del.amount > 0, "No delegation");
        require(!del.unbonding, "Already unbonding");

        del.unbonding = true;
        del.unbondingEnd = block.timestamp + UNBONDING_PERIOD;

        emit UndelegationStarted(msg.sender, agent, del.unbondingEnd);
    }

    /// @notice Withdraw after unbonding
    function withdrawDelegation(address agent) external {
        Delegation storage del = delegations[msg.sender][agent];
        require(del.unbonding, "Not unbonding");
        require(block.timestamp >= del.unbondingEnd, "Unbonding incomplete");

        uint256 amount = del.amount;

        totalDelegated[agent] -= amount;
        delete delegations[msg.sender][agent];

        nztToken.transfer(msg.sender, amount);

        _updateAgentStake(agent);

        emit DelegationWithdrawn(msg.sender, agent, amount);
    }

    /// @notice Claim delegation rewards
    function claimDelegationRewards(address agent) external {
        Delegation storage del = delegations[msg.sender][agent];
        require(del.amount > 0, "No delegation");

        uint256 agentRewards = calculateAgentRewards(agent);
        uint256 delegatorShare = (agentRewards * del.commission) / 10000;

        nztToken.transfer(msg.sender, delegatorShare);

        emit DelegationRewardsClaimed(msg.sender, agent, delegatorShare);
    }
}

function stakeLocked(uint256 amount, uint256 duration) external {
    require(duration >= 90 days, "Min 3 months");

    uint256 multiplier = calculateMultiplier(duration);

    stakes[msg.sender].amount += amount;
    stakes[msg.sender].multiplier = multiplier;
    stakes[msg.sender].lockedUntil = block.timestamp + duration;

    emit StakedLocked(msg.sender, amount, duration, multiplier);
}

function calculateMultiplier(uint256 duration) internal pure returns (uint256) {
    if (duration >= 730 days) return 300; // 3.0x
    if (duration >= 365 days) return 200; // 2.0x
    if (duration >= 180 days) return 150; // 1.5x
    if (duration >= 90 days) return 120;  // 1.2x
    return 100; // 1.0x
}

class StakingVault {
  async deposit(amount) {
    // Deposit into vault
    await this.vaultContract.deposit(amount);
  }

  async autoCompound() {
    // Claim rewards
    const rewards = await this.stakingContract.pendingRewards(this.vaultAddress);

    if (rewards > 0) {
      // Claim and re-stake
      await this.stakingContract.claimRewards();
      await this.stakingContract.stake(rewards);

      // Track compound
      this.compoundHistory.push({
        timestamp: Date.now(),
        amount: rewards,
        newTotal: await this.stakingContract.stakes(this.vaultAddress)
      });
    }
  }

  async calculateAPY(timeframe = 365) {
    const deposits = this.compoundHistory;
    const initial = deposits[0].amount;
    const final = deposits[deposits.length - 1].newTotal;

    const apy = ((final / initial) ** (365 / timeframe) - 1) * 100;
    return apy;
  }
}

// Get comprehensive staking info
async function getStakingInfo(address) {
  const stakingContract = new ethers.Contract(stakingAddress, stakingAbi, provider);

  const stake = await stakingContract.stakes(address);
  const pending = await stakingContract.pendingRewards(address);
  const claimed = await stakingContract.claimedRewards(address);
  const totalStaked = await stakingContract.totalStaked();

  const stakeAmount = parseFloat(ethers.formatEther(stake.amount));
  const pendingAmount = parseFloat(ethers.formatEther(pending));
  const claimedAmount = parseFloat(ethers.formatEther(claimed));

  const stakedPercentage = (stakeAmount / parseFloat(ethers.formatEther(totalStaked))) * 100;

  return {
    staked: stakeAmount,
    pending: pendingAmount,
    claimed: claimedAmount,
    totalEarned: pendingAmount + claimedAmount,
    stakedPercentage: stakedPercentage.toFixed(4),
    unbonding: stake.unbonding,
    unbondingEnd: stake.unbonding ? new Date(Number(stake.unbondingEnd) * 1000) : null
  };
}