Decay Upkeep

{
  "name": "decay-upkeep",
  "description": "Building decay and upkeep systems for survival games. Use when implementing timer-based decay, Tool Cupboard patterns, resource upkeep costs, or server performance management through automatic cleanup.",
  "tags": [
    "building-game",
    "javascript",
    "code-generation"
  ],
  "sub_skills": [],
  "source": "claude-user",
  "type": "template",
  "depends_on": [],
  "enhances": [
    "structural-physics",
    "multiplayer-building"
  ],
  "last_reviewed_at": "2026-06-02",
  "review_score": 66,
  "relevance_tier": "B"
}

/**
 * CleanupScheduler - Automated cleanup of decayed structures
 * 
 * Server-side system for managing abandoned structure removal,
 * with configurable thresholds, batch processing, and notifications.
 * 
 * Usage:
 *   const cleanup = new CleanupScheduler({ decayManager });
 *   cleanup.tick(Date.now()); // Called from server loop
 *   const stats = cleanup.getStatistics();
 */

/**
 * Cleanup strategies
 */
export const CleanupStrategy = {
  IMMEDIATE: 'immediate',     // Remove as soon as threshold hit
  BATCHED: 'batched',         // Process in batches at intervals
  SCHEDULED: 'scheduled'      // Run at specific times
};

export class CleanupScheduler {
  /**
   * Create cleanup scheduler
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    this.decayManager = options.decayManager;
    this.strategy = options.strategy ?? CleanupStrategy.BATCHED;
    
    // Timing
    this.cleanupInterval = options.cleanupInterval ?? 60 * 60 * 1000; // 1 hour
    this.lastCleanup = 0;
    
    // Thresholds
    this.destroyThreshold = options.destroyThreshold ?? 0; // Health % to destroy
    this.warnThreshold = options.warnThreshold ?? 25;
    this.criticalThreshold = options.criticalThreshold ?? 10;
    
    // Batch processing
    this.batchSize = options.batchSize ?? 100;
    this.maxBatchTime = options.maxBatchTime ?? 50; // Max ms per batch
    
    // Tracking
    this.totalCleaned = 0;
    this.cleanupHistory = [];
    this.maxHistorySize = options.maxHistorySize ?? 100;
    this.pendingWarnings = new Map();
    
    // Callbacks
    this.onCleanup = options.onCleanup ?? null;
    this.onWarning = options.onWarning ?? null;
    this.onCritical = options.onCritical ?? null;
    this.onBatchComplete = options.onBatchComplete ?? null;
  }

  /**
   * Main tick - call from server loop
   * @param {number} currentTime - Current timestamp
   * @returns {Object} Tick results
   */
  tick(currentTime) {
    if (!this.decayManager) {
      return { ran: false, reason: 'No decay manager configured' };
    }

    const elapsed = currentTime - this.lastCleanup;

    if (elapsed < this.cleanupInterval) {
      return { 
        ran: false, 
        reason: 'Interval not reached', 
        nextIn: this.cleanupInterval - elapsed 
      };
    }

    this.lastCleanup = currentTime;
    return this.runCleanup();
  }

  /**
   * Execute cleanup pass
   * @returns {Object} Cleanup results
   */
  runCleanup() {
    const startTime = performance.now();
    const results = {
      ran: true,
      timestamp: Date.now(),
      destroyed: [],
      warned: [],
      critical: [],
      processed: 0,
      batchesRun: 0,
      timeSpent: 0
    };

    let processed = 0;
    let batchStart = performance.now();

    for (const [id, data] of this.decayManager.pieces) {
      // Check batch limits
      if (processed >= this.batchSize) {
        results.batchesRun++;
        
        // Check time limit
        if (performance.now() - startTime > this.maxBatchTime) {
          break;
        }
        
        processed = 0;
        batchStart = performance.now();
      }

      const piece = data.piece;
      const maxHealth = piece.maxHealth ?? 100;
      const health = piece.health ?? maxHealth;
      const healthPercent = (health / maxHealth) * 100;

      if (healthPercent <= this.destroyThreshold) {
        results.destroyed.push({
          id: piece.id,
          position: piece.position?.clone(),
          material: piece.material?.name,
          structureId: piece.structureId
        });
      } else if (healthPercent <= this.criticalThreshold) {
        results.critical.push(piece);
      } else if (healthPercent <= this.warnThreshold) {
        results.warned.push(piece);
      }

      processed++;
      results.processed++;
    }

    // Execute destruction
    for (const destroyed of results.destroyed) {
      this.decayManager.removePiece(destroyed.id);
      this.totalCleaned++;
    }

    results.timeSpent = performance.now() - startTime;

    // Record history
    this.recordHistory(results);

    // Fire callbacks
    this.fireCallbacks(results);

    return results;
  }

  /**
   * Force immediate cleanup of specific structure
   * @param {string} structureId - Structure to clean up
   * @returns {Object} Cleanup results
   */
  forceCleanupStructure(structureId) {
    if (!this.decayManager) {
      return { success: false, reason: 'No decay manager' };
    }

    const toRemove = [];

    for (const [id, data] of this.decayManager.pieces) {
      if (data.piece.structureId === structureId) {
        toRemove.push(id);
      }
    }

    for (const id of toRemove) {
      this.decayManager.removePiece(id);
      this.totalCleaned++;
    }

    this.recordHistory({
      ran: true,
      timestamp: Date.now(),
      destroyed: toRemove.map(id => ({ id, structureId })),
      warned: [],
      critical: [],
      processed: toRemove.length,
      forced: true
    });

    return { 
      success: true, 
      removed: toRemove.length, 
      structureId 
    };
  }

  /**
   * Force cleanup of all pieces below threshold
   * @param {number} healthThreshold - Health percentage threshold
   * @returns {Object} Cleanup results
   */
  forceCleanupBelow(healthThreshold) {
    if (!this.decayManager) {
      return { success: false, reason: 'No decay manager' };
    }

    const toRemove = [];

    for (const [id, data] of this.decayManager.pieces) {
      const piece = data.piece;
      const maxHealth = piece.maxHealth ?? 100;
      const healthPercent = ((piece.health ?? maxHealth) / maxHealth) * 100;

      if (healthPercent <= healthThreshold) {
        toRemove.push({
          id,
          healthPercent,
          position: piece.position?.clone()
        });
      }
    }

    for (const item of toRemove) {
      this.decayManager.removePiece(item.id);
      this.totalCleaned++;
    }

    this.recordHistory({
      ran: true,
      timestamp: Date.now(),
      destroyed: toRemove,
      warned: [],
      critical: [],
      processed: toRemove.length,
      forced: true,
      threshold: healthThreshold
    });

    return {
      success: true,
      removed: toRemove.length,
      threshold: healthThreshold
    };
  }

  /**
   * Record cleanup in history
   */
  recordHistory(results) {
    this.cleanupHistory.push({
      timestamp: results.timestamp,
      destroyed: results.destroyed.length,
      warned: results.warned.length,
      critical: results.critical.length,
      processed: results.processed,
      forced: results.forced ?? false
    });

    // Trim history
    while (this.cleanupHistory.length > this.maxHistorySize) {
      this.cleanupHistory.shift();
    }
  }

  /**
   * Fire appropriate callbacks
   */
  fireCallbacks(results) {
    if (results.destroyed.length > 0 && this.onCleanup) {
      this.onCleanup(results.destroyed);
    }

    if (results.warned.length > 0 && this.onWarning) {
      // Group by owner for notifications
      const byOwner = this.groupByOwner(results.warned);
      for (const [ownerId, pieces] of Object.entries(byOwner)) {
        this.onWarning(ownerId, pieces);
      }
    }

    if (results.critical.length > 0 && this.onCritical) {
      const byOwner = this.groupByOwner(results.critical);
      for (const [ownerId, pieces] of Object.entries(byOwner)) {
        this.onCritical(ownerId, pieces);
      }
    }

    if (this.onBatchComplete) {
      this.onBatchComplete(results);
    }
  }

  /**
   * Group pieces by owner
   */
  groupByOwner(pieces) {
    const grouped = {};

    for (const piece of pieces) {
      const ownerId = piece.ownerId ?? piece.structureId ?? 'unknown';
      if (!grouped[ownerId]) {
        grouped[ownerId] = [];
      }
      grouped[ownerId].push(piece);
    }

    return grouped;
  }

  /**
   * Get comprehensive statistics
   * @returns {Object} Statistics
   */
  getStatistics() {
    if (!this.decayManager) {
      return { error: 'No decay manager configured' };
    }

    const stats = {
      totalTracked: 0,
      totalCleaned: this.totalCleaned,
      byHealthState: {
        healthy: 0,
        damaged: 0,
        critical: 0,
        failing: 0
      },
      byMaterial: {},
      protectedCount: 0,
      unprotectedCount: 0,
      averageHealth: 0,
      lowestHealth: 100,
      cleanupHistory: this.getHistorySummary()
    };

    let totalHealth = 0;

    for (const [id, data] of this.decayManager.pieces) {
      const piece = data.piece;
      const maxHealth = piece.maxHealth ?? 100;
      const health = piece.health ?? maxHealth;
      const healthPercent = (health / maxHealth) * 100;

      stats.totalTracked++;
      totalHealth += healthPercent;
      stats.lowestHealth = Math.min(stats.lowestHealth, healthPercent);

      // By health state
      if (healthPercent > 75) stats.byHealthState.healthy++;
      else if (healthPercent > 50) stats.byHealthState.damaged++;
      else if (healthPercent > 25) stats.byHealthState.critical++;
      else stats.byHealthState.failing++;

      // By material
      const material = piece.material?.name ?? 'Unknown';
      stats.byMaterial[material] = (stats.byMaterial[material] ?? 0) + 1;

      // Protected status
      if (this.decayManager.isPieceProtected(piece)) {
        stats.protectedCount++;
      } else {
        stats.unprotectedCount++;
      }
    }

    stats.averageHealth = stats.totalTracked > 0 
      ? totalHealth / stats.totalTracked 
      : 0;

    return stats;
  }

  /**
   * Get history summary
   */
  getHistorySummary() {
    const recent = this.cleanupHistory.slice(-10);
    
    return {
      totalRuns: this.cleanupHistory.length,
      recentRuns: recent,
      totalDestroyed: this.cleanupHistory.reduce((sum, h) => sum + h.destroyed, 0),
      averageDestroyed: this.cleanupHistory.length > 0
        ? this.cleanupHistory.reduce((sum, h) => sum + h.destroyed, 0) / this.cleanupHistory.length
        : 0
    };
  }

  /**
   * Get structures at risk (grouped pieces near decay)
   * @returns {Array} At-risk structures
   */
  getAtRiskStructures() {
    if (!this.decayManager) return [];

    const structures = new Map();

    for (const [id, data] of this.decayManager.pieces) {
      const piece = data.piece;
      const structureId = piece.structureId ?? 'unassigned';
      
      if (!structures.has(structureId)) {
        structures.set(structureId, {
          id: structureId,
          pieces: [],
          lowestHealth: 100,
          averageHealth: 0,
          criticalCount: 0
        });
      }

      const structure = structures.get(structureId);
      const maxHealth = piece.maxHealth ?? 100;
      const healthPercent = ((piece.health ?? maxHealth) / maxHealth) * 100;

      structure.pieces.push(piece);
      structure.lowestHealth = Math.min(structure.lowestHealth, healthPercent);

      if (healthPercent <= this.criticalThreshold) {
        structure.criticalCount++;
      }
    }

    // Calculate averages and filter to at-risk
    const atRisk = [];

    for (const [id, structure] of structures) {
      const totalHealth = structure.pieces.reduce((sum, p) => {
        const max = p.maxHealth ?? 100;
        return sum + ((p.health ?? max) / max) * 100;
      }, 0);

      structure.averageHealth = totalHealth / structure.pieces.length;
      structure.pieceCount = structure.pieces.length;
      delete structure.pieces; // Remove piece references for cleaner output

      if (structure.lowestHealth <= this.warnThreshold || structure.criticalCount > 0) {
        atRisk.push(structure);
      }
    }

    // Sort by lowest health
    atRisk.sort((a, b) => a.lowestHealth - b.lowestHealth);

    return atRisk;
  }

  /**
   * Estimate server entity reduction
   * @returns {Object} Reduction estimate
   */
  estimateReduction() {
    if (!this.decayManager) return { error: 'No decay manager' };

    let wouldDestroy = 0;
    let wouldWarn = 0;

    for (const [id, data] of this.decayManager.pieces) {
      const piece = data.piece;
      const maxHealth = piece.maxHealth ?? 100;
      const healthPercent = ((piece.health ?? maxHealth) / maxHealth) * 100;

      if (healthPercent <= this.destroyThreshold) {
        wouldDestroy++;
      } else if (healthPercent <= this.warnThreshold) {
        wouldWarn++;
      }
    }

    const total = this.decayManager.pieces.size;

    return {
      total,
      wouldDestroy,
      wouldWarn,
      reductionPercent: total > 0 ? (wouldDestroy / total) * 100 : 0,
      atRiskPercent: total > 0 ? ((wouldDestroy + wouldWarn) / total) * 100 : 0
    };
  }

  /**
   * Set cleanup interval
   * @param {number} intervalMs - New interval in milliseconds
   */
  setInterval(intervalMs) {
    this.cleanupInterval = Math.max(60000, intervalMs); // Minimum 1 minute
    return { interval: this.cleanupInterval };
  }

  /**
   * Set thresholds
   * @param {Object} thresholds - New thresholds
   */
  setThresholds(thresholds) {
    if (thresholds.destroy !== undefined) {
      this.destroyThreshold = Math.max(0, Math.min(100, thresholds.destroy));
    }
    if (thresholds.warn !== undefined) {
      this.warnThreshold = Math.max(0, Math.min(100, thresholds.warn));
    }
    if (thresholds.critical !== undefined) {
      this.criticalThreshold = Math.max(0, Math.min(100, thresholds.critical));
    }

    return {
      destroy: this.destroyThreshold,
      warn: this.warnThreshold,
      critical: this.criticalThreshold
    };
  }

  /**
   * Serialize state
   */
  serialize() {
    return {
      version: 1,
      totalCleaned: this.totalCleaned,
      lastCleanup: this.lastCleanup,
      cleanupHistory: this.cleanupHistory,
      thresholds: {
        destroy: this.destroyThreshold,
        warn: this.warnThreshold,
        critical: this.criticalThreshold
      }
    };
  }

  /**
   * Deserialize state
   */
  deserialize(data) {
    if (data.version !== 1) {
      throw new Error(`Unsupported cleanup scheduler version: ${data.version}`);
    }

    this.totalCleaned = data.totalCleaned;
    this.lastCleanup = data.lastCleanup;
    this.cleanupHistory = data.cleanupHistory;
    this.destroyThreshold = data.thresholds.destroy;
    this.warnThreshold = data.thresholds.warn;
    this.criticalThreshold = data.thresholds.critical;

    return { restored: true };
  }
}

export default CleanupScheduler;

/**
 * DecayManager - Manages decay for building pieces
 * 
 * Implements timer-based decay with material-specific rates,
 * damage states for visual feedback, and protection zone support.
 * 
 * Usage:
 *   const decay = new DecayManager({ mode: 'rust' });
 *   decay.addPiece(piece);
 *   decay.tick(Date.now()); // Called from game loop
 */

import * as THREE from 'three';

/**
 * Decay modes matching game styles
 */
export const DecayMode = {
  RUST: 'rust',       // Fast decay (hours), Tool Cupboard protection
  ARK: 'ark',         // Slow decay (days), tribe-based protection
  VALHEIM: 'valheim', // No decay, durability damage from weather
  CUSTOM: 'custom'    // User-defined rates
};

/**
 * Default decay rates by material (seconds to full decay)
 */
export const DefaultDecayRates = {
  rust: {
    TWIG: { time: 1 * 60 * 60, canProtect: false },
    WOOD: { time: 3 * 60 * 60, canProtect: true },
    STONE: { time: 5 * 60 * 60, canProtect: true },
    METAL: { time: 8 * 60 * 60, canProtect: true },
    ARMORED: { time: 12 * 60 * 60, canProtect: true }
  },
  ark: {
    THATCH: { time: 4 * 24 * 60 * 60, canProtect: true },
    WOOD: { time: 8 * 24 * 60 * 60, canProtect: true },
    STONE: { time: 12 * 24 * 60 * 60, canProtect: true },
    METAL: { time: 16 * 24 * 60 * 60, canProtect: true },
    TEK: { time: 20 * 24 * 60 * 60, canProtect: true }
  },
  valheim: {
    WOOD: { time: Infinity, canProtect: false },
    STONE: { time: Infinity, canProtect: false },
    IRON: { time: Infinity, canProtect: false }
  }
};

/**
 * Damage state definitions
 */
export const DamageState = {
  HEALTHY: 'healthy',
  DAMAGED: 'damaged',
  CRITICAL: 'critical',
  FAILING: 'failing'
};

export class DecayManager {
  /**
   * Create decay manager
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    this.mode = options.mode ?? DecayMode.RUST;
    this.decayRates = options.decayRates ?? DefaultDecayRates[this.mode] ?? DefaultDecayRates.rust;
    this.decayMultiplier = options.decayMultiplier ?? 1.0;
    this.tickInterval = options.tickInterval ?? 60; // Seconds between decay checks
    this.enabled = options.enabled ?? true;
    
    // Piece tracking
    this.pieces = new Map();
    this.protectedAreas = [];
    
    // Timing
    this.lastTick = 0;
    this.totalDecayTicks = 0;
    
    // Damage state thresholds
    this.damageThresholds = options.damageThresholds ?? [
      { threshold: 0.75, state: DamageState.HEALTHY },
      { threshold: 0.50, state: DamageState.DAMAGED },
      { threshold: 0.25, state: DamageState.CRITICAL },
      { threshold: 0.00, state: DamageState.FAILING }
    ];
    
    // Event callbacks
    this.onPieceDecayed = options.onPieceDecayed ?? null;
    this.onDamageStateChanged = options.onDamageStateChanged ?? null;
    this.onDecayTick = options.onDecayTick ?? null;
  }

  /**
   * Add piece to decay tracking
   * @param {Object} piece - Building piece to track
   */
  addPiece(piece) {
    if (this.pieces.has(piece.id)) {
      return { success: false, reason: 'Piece already tracked' };
    }

    const data = {
      piece,
      addedTime: Date.now(),
      lastDecayTime: Date.now(),
      damageState: this.calculateDamageState(piece),
      totalDecayDamage: 0
    };

    this.pieces.set(piece.id, data);

    return { success: true, data };
  }

  /**
   * Remove piece from decay tracking
   * @param {string} pieceId - ID of piece to remove
   */
  removePiece(pieceId) {
    const existed = this.pieces.has(pieceId);
    this.pieces.delete(pieceId);
    return { success: existed };
  }

  /**
   * Add a protected area (Tool Cupboard, etc.)
   * @param {Object} area - Protection area with contains() method
   */
  addProtectedArea(area) {
    this.protectedAreas.push(area);
    return { areaCount: this.protectedAreas.length };
  }

  /**
   * Remove a protected area
   * @param {string} areaId - ID of area to remove
   */
  removeProtectedArea(areaId) {
    const before = this.protectedAreas.length;
    this.protectedAreas = this.protectedAreas.filter(a => a.id !== areaId);
    return { removed: before - this.protectedAreas.length };
  }

  /**
   * Main decay tick - call from game loop
   * @param {number} currentTime - Current timestamp (ms)
   * @returns {Object} Tick results
   */
  tick(currentTime) {
    if (!this.enabled) {
      return { ran: false, reason: 'Decay disabled' };
    }

    const deltaMs = currentTime - this.lastTick;
    const deltaSeconds = deltaMs / 1000;

    if (deltaSeconds < this.tickInterval) {
      return { ran: false, reason: 'Interval not reached', nextIn: this.tickInterval - deltaSeconds };
    }

    this.lastTick = currentTime;
    this.totalDecayTicks++;

    const results = {
      ran: true,
      tickNumber: this.totalDecayTicks,
      deltaTime: deltaSeconds,
      decayed: 0,
      destroyed: 0,
      stateChanges: 0,
      toDestroy: []
    };

    // Process each piece
    for (const [id, data] of this.pieces) {
      const piece = data.piece;
      
      // Check protection
      const isProtected = this.isPieceProtected(piece);
      
      // Calculate decay damage
      const damage = this.calculateDecayDamage(piece, deltaSeconds, isProtected);
      
      if (damage > 0) {
        // Apply damage
        piece.health = Math.max(0, (piece.health ?? piece.maxHealth ?? 100) - damage);
        data.totalDecayDamage += damage;
        results.decayed++;

        // Update damage state
        const newState = this.calculateDamageState(piece);
        if (newState !== data.damageState) {
          const oldState = data.damageState;
          data.damageState = newState;
          results.stateChanges++;

          if (this.onDamageStateChanged) {
            this.onDamageStateChanged(piece, newState, oldState);
          }
        }

        // Mark for destruction if depleted
        if (piece.health <= 0) {
          results.toDestroy.push(id);
        }
      }
    }

    // Destroy depleted pieces
    for (const id of results.toDestroy) {
      const data = this.pieces.get(id);
      if (data && this.onPieceDecayed) {
        this.onPieceDecayed(data.piece);
      }
      this.pieces.delete(id);
      results.destroyed++;
    }

    // Callback
    if (this.onDecayTick) {
      this.onDecayTick(results);
    }

    return results;
  }

  /**
   * Check if piece is in a protected area
   * @param {Object} piece - Piece to check
   * @returns {boolean} Whether piece is protected
   */
  isPieceProtected(piece) {
    for (const area of this.protectedAreas) {
      // Area must contain piece position
      if (area.contains && area.contains(piece.position)) {
        // Area must have upkeep (if applicable)
        if (typeof area.hasUpkeep === 'function') {
          if (area.hasUpkeep()) {
            return true;
          }
        } else {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * Calculate decay damage for a piece
   * @param {Object} piece - Piece to calculate for
   * @param {number} deltaTime - Time elapsed (seconds)
   * @param {boolean} isProtected - Whether piece is protected
   * @returns {number} Damage to apply
   */
  calculateDecayDamage(piece, deltaTime, isProtected) {
    const materialName = piece.material?.name?.toUpperCase() ?? 'WOOD';
    const decayInfo = this.decayRates[materialName];

    if (!decayInfo) return 0;

    // Check if material can be protected
    if (isProtected && decayInfo.canProtect) {
      return 0;
    }

    // No decay if infinite time
    if (decayInfo.time === Infinity) return 0;

    // Calculate decay rate (HP per second)
    const maxHealth = piece.maxHealth ?? 100;
    const decayRate = maxHealth / decayInfo.time;

    // Apply multiplier and delta time
    return decayRate * deltaTime * this.decayMultiplier;
  }

  /**
   * Calculate damage state from piece health
   * @param {Object} piece - Piece to check
   * @returns {string} Damage state
   */
  calculateDamageState(piece) {
    const maxHealth = piece.maxHealth ?? 100;
    const health = piece.health ?? maxHealth;
    const healthPercent = health / maxHealth;

    for (const { threshold, state } of this.damageThresholds) {
      if (healthPercent >= threshold) {
        return state;
      }
    }

    return DamageState.FAILING;
  }

  /**
   * Get decay status for a piece (for UI)
   * @param {string} pieceId - ID of piece
   * @returns {Object|null} Decay status
   */
  getDecayStatus(pieceId) {
    const data = this.pieces.get(pieceId);
    if (!data) return null;

    const piece = data.piece;
    const isProtected = this.isPieceProtected(piece);
    const materialName = piece.material?.name?.toUpperCase() ?? 'WOOD';
    const decayInfo = this.decayRates[materialName];

    // Calculate time until decay completes
    let timeToDecay = Infinity;
    if (decayInfo && !isProtected && decayInfo.time !== Infinity) {
      const healthPercent = (piece.health ?? piece.maxHealth) / piece.maxHealth;
      timeToDecay = decayInfo.time * healthPercent / this.decayMultiplier;
    }

    return {
      pieceId,
      health: piece.health ?? piece.maxHealth,
      maxHealth: piece.maxHealth ?? 100,
      healthPercent: ((piece.health ?? piece.maxHealth) / (piece.maxHealth ?? 100)) * 100,
      damageState: data.damageState,
      isProtected,
      canProtect: decayInfo?.canProtect ?? false,
      timeToDecay,
      timeToDecayFormatted: this.formatTime(timeToDecay),
      material: materialName,
      totalDecayDamage: data.totalDecayDamage
    };
  }

  /**
   * Get all pieces in a specific damage state
   * @param {string} state - Damage state to filter by
   * @returns {Array} Pieces in that state
   */
  getPiecesByState(state) {
    const result = [];
    for (const [id, data] of this.pieces) {
      if (data.damageState === state) {
        result.push(data.piece);
      }
    }
    return result;
  }

  /**
   * Get summary statistics
   * @returns {Object} Decay statistics
   */
  getStatistics() {
    const stats = {
      total: 0,
      protected: 0,
      byState: {
        [DamageState.HEALTHY]: 0,
        [DamageState.DAMAGED]: 0,
        [DamageState.CRITICAL]: 0,
        [DamageState.FAILING]: 0
      },
      byMaterial: {}
    };

    for (const [id, data] of this.pieces) {
      stats.total++;
      stats.byState[data.damageState]++;

      const material = data.piece.material?.name ?? 'Unknown';
      stats.byMaterial[material] = (stats.byMaterial[material] ?? 0) + 1;

      if (this.isPieceProtected(data.piece)) {
        stats.protected++;
      }
    }

    return stats;
  }

  /**
   * Repair piece to full health
   * @param {string} pieceId - ID of piece to repair
   * @returns {Object} Repair result
   */
  repairPiece(pieceId) {
    const data = this.pieces.get(pieceId);
    if (!data) {
      return { success: false, reason: 'Piece not found' };
    }

    const piece = data.piece;
    const damageTaken = (piece.maxHealth ?? 100) - (piece.health ?? 0);
    
    piece.health = piece.maxHealth ?? 100;
    data.damageState = DamageState.HEALTHY;
    data.totalDecayDamage = 0;

    return {
      success: true,
      repaired: damageTaken,
      newHealth: piece.health
    };
  }

  /**
   * Set decay multiplier (for server admin)
   * @param {number} multiplier - New multiplier
   */
  setDecayMultiplier(multiplier) {
    this.decayMultiplier = Math.max(0, multiplier);
    return { multiplier: this.decayMultiplier };
  }

  /**
   * Enable or disable decay
   * @param {boolean} enabled - Whether decay is enabled
   */
  setEnabled(enabled) {
    this.enabled = enabled;
    return { enabled: this.enabled };
  }

  /**
   * Format time in human-readable format
   * @param {number} seconds - Time in seconds
   * @returns {string} Formatted time
   */
  formatTime(seconds) {
    if (seconds === Infinity) return 'Never';
    if (seconds <= 0) return 'Now';

    const hours = Math.floor(seconds / 3600);
    const minutes = Math.floor((seconds % 3600) / 60);

    if (hours > 24) {
      const days = Math.floor(hours / 24);
      return `${days}d ${hours % 24}h`;
    }
    if (hours > 0) {
      return `${hours}h ${minutes}m`;
    }
    return `${minutes}m`;
  }

  /**
   * Serialize state for saving
   * @returns {Object} Serialized state
   */
  serialize() {
    const pieces = [];
    for (const [id, data] of this.pieces) {
      pieces.push({
        id,
        health: data.piece.health,
        addedTime: data.addedTime,
        lastDecayTime: data.lastDecayTime,
        damageState: data.damageState,
        totalDecayDamage: data.totalDecayDamage
      });
    }

    return {
      version: 1,
      mode: this.mode,
      decayMultiplier: this.decayMultiplier,
      enabled: this.enabled,
      lastTick: this.lastTick,
      totalDecayTicks: this.totalDecayTicks,
      pieces
    };
  }

  /**
   * Restore state from saved data
   * @param {Object} data - Saved state
   * @param {Map} pieceMap - Map of piece IDs to piece objects
   */
  deserialize(data, pieceMap) {
    if (data.version !== 1) {
      throw new Error(`Unsupported decay save version: ${data.version}`);
    }

    this.mode = data.mode;
    this.decayMultiplier = data.decayMultiplier;
    this.enabled = data.enabled;
    this.lastTick = data.lastTick;
    this.totalDecayTicks = data.totalDecayTicks;

    this.pieces.clear();
    for (const saved of data.pieces) {
      const piece = pieceMap.get(saved.id);
      if (piece) {
        piece.health = saved.health;
        this.pieces.set(saved.id, {
          piece,
          addedTime: saved.addedTime,
          lastDecayTime: saved.lastDecayTime,
          damageState: saved.damageState,
          totalDecayDamage: saved.totalDecayDamage
        });
      }
    }

    return { restored: this.pieces.size };
  }
}

export default DecayManager;

/**
 * ToolCupboard - Protection zone with authorization and resource storage
 * 
 * Implements Rust-style Tool Cupboard mechanics: spherical protection zone,
 * player authorization, and resource storage for upkeep payment.
 * 
 * Usage:
 *   const tc = new ToolCupboard({ radius: 30, ownerId: 'player1' });
 *   tc.setPosition(position);
 *   tc.authorize('player2', 'player1');
 *   tc.depositResources({ wood: 1000 });
 */

import * as THREE from 'three';

/**
 * Authorization levels
 */
export const AuthLevel = {
  NONE: 'none',
  BUILD: 'build',       // Can build in zone
  MANAGE: 'manage',     // Can authorize others
  OWNER: 'owner'        // Full control
};

export class ToolCupboard {
  /**
   * Create Tool Cupboard
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    this.id = options.id ?? `tc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    this.position = options.position ? new THREE.Vector3().copy(options.position) : new THREE.Vector3();
    this.radius = options.radius ?? 30;
    this.radiusSquared = this.radius * this.radius;
    
    // Authorization
    this.ownerId = options.ownerId ?? null;
    this.authorizedPlayers = new Map(); // playerId -> AuthLevel
    if (this.ownerId) {
      this.authorizedPlayers.set(this.ownerId, AuthLevel.OWNER);
    }
    
    // Resource storage
    this.resources = new Map();
    this.maxStorage = options.maxStorage ?? {
      wood: 10000,
      stone: 10000,
      metal: 5000,
      highQuality: 1000,
      thatch: 5000,
      fiber: 5000
    };
    
    // Protected pieces
    this.protectedPieces = new Set();
    
    // Upkeep tracking
    this.lastUpkeepTime = Date.now();
    this.upkeepInterval = options.upkeepInterval ?? 24 * 60 * 60 * 1000;
    this.upkeepBuffer = options.upkeepBuffer ?? 3 * 24 * 60 * 60 * 1000;
    this.upkeepPaid = true;
    
    // Callbacks
    this.onAuthorized = options.onAuthorized ?? null;
    this.onDeauthorized = options.onDeauthorized ?? null;
    this.onResourcesChanged = options.onResourcesChanged ?? null;
    this.onUpkeepFailed = options.onUpkeepFailed ?? null;
  }

  /**
   * Set position of Tool Cupboard
   * @param {THREE.Vector3} position - New position
   */
  setPosition(position) {
    this.position.copy(position);
    this.updateProtectedPieces();
  }

  /**
   * Check if position is within protection radius
   * @param {THREE.Vector3} position - Position to check
   * @returns {boolean} Whether position is protected
   */
  contains(position) {
    const dx = position.x - this.position.x;
    const dy = position.y - this.position.y;
    const dz = position.z - this.position.z;
    return (dx * dx + dy * dy + dz * dz) <= this.radiusSquared;
  }

  /**
   * Get distance from TC center
   * @param {THREE.Vector3} position - Position to measure
   * @returns {number} Distance in units
   */
  getDistance(position) {
    return this.position.distanceTo(position);
  }

  /**
   * Check if player is authorized
   * @param {string} playerId - Player to check
   * @param {string} requiredLevel - Minimum auth level required
   * @returns {boolean} Whether player has required authorization
   */
  isAuthorized(playerId, requiredLevel = AuthLevel.BUILD) {
    const level = this.authorizedPlayers.get(playerId);
    if (!level) return false;
    
    const levels = [AuthLevel.NONE, AuthLevel.BUILD, AuthLevel.MANAGE, AuthLevel.OWNER];
    const playerIndex = levels.indexOf(level);
    const requiredIndex = levels.indexOf(requiredLevel);
    
    return playerIndex >= requiredIndex;
  }

  /**
   * Get player's authorization level
   * @param {string} playerId - Player to check
   * @returns {string} Authorization level
   */
  getAuthLevel(playerId) {
    return this.authorizedPlayers.get(playerId) ?? AuthLevel.NONE;
  }

  /**
   * Authorize a player
   * @param {string} playerId - Player to authorize
   * @param {string} authorizingPlayerId - Player performing authorization
   * @param {string} level - Authorization level to grant
   * @returns {Object} Result of authorization attempt
   */
  authorize(playerId, authorizingPlayerId, level = AuthLevel.BUILD) {
    // Check if authorizing player has permission
    if (!this.isAuthorized(authorizingPlayerId, AuthLevel.MANAGE)) {
      return { 
        success: false, 
        reason: 'Insufficient permissions to authorize players' 
      };
    }

    // Cannot grant higher level than own
    const authorizerLevel = this.getAuthLevel(authorizingPlayerId);
    const levels = [AuthLevel.NONE, AuthLevel.BUILD, AuthLevel.MANAGE, AuthLevel.OWNER];
    
    if (levels.indexOf(level) > levels.indexOf(authorizerLevel)) {
      return { 
        success: false, 
        reason: 'Cannot grant authorization level higher than own' 
      };
    }

    // Cannot change owner
    if (playerId === this.ownerId && level !== AuthLevel.OWNER) {
      return { 
        success: false, 
        reason: 'Cannot change owner authorization level' 
      };
    }

    this.authorizedPlayers.set(playerId, level);

    if (this.onAuthorized) {
      this.onAuthorized(playerId, level, authorizingPlayerId);
    }

    return { 
      success: true, 
      playerId, 
      level,
      totalAuthorized: this.authorizedPlayers.size 
    };
  }

  /**
   * Deauthorize a player
   * @param {string} playerId - Player to deauthorize
   * @param {string} deauthorizingPlayerId - Player performing deauthorization
   * @returns {Object} Result of deauthorization attempt
   */
  deauthorize(playerId, deauthorizingPlayerId) {
    if (!this.isAuthorized(deauthorizingPlayerId, AuthLevel.MANAGE)) {
      return { 
        success: false, 
        reason: 'Insufficient permissions to deauthorize players' 
      };
    }

    if (playerId === this.ownerId) {
      return { 
        success: false, 
        reason: 'Cannot deauthorize owner' 
      };
    }

    const hadAuth = this.authorizedPlayers.has(playerId);
    this.authorizedPlayers.delete(playerId);

    if (hadAuth && this.onDeauthorized) {
      this.onDeauthorized(playerId, deauthorizingPlayerId);
    }

    return { 
      success: hadAuth, 
      reason: hadAuth ? null : 'Player was not authorized',
      totalAuthorized: this.authorizedPlayers.size
    };
  }

  /**
   * Clear all authorizations except owner
   * @param {string} requestingPlayerId - Player requesting clear
   * @returns {Object} Result
   */
  clearAuthorizations(requestingPlayerId) {
    if (!this.isAuthorized(requestingPlayerId, AuthLevel.OWNER)) {
      return { 
        success: false, 
        reason: 'Only owner can clear all authorizations' 
      };
    }

    const count = this.authorizedPlayers.size - 1; // Exclude owner
    
    this.authorizedPlayers.clear();
    this.authorizedPlayers.set(this.ownerId, AuthLevel.OWNER);

    return { success: true, cleared: count };
  }

  /**
   * Get list of authorized players
   * @returns {Array} List of authorized players with levels
   */
  getAuthorizedPlayers() {
    const players = [];
    for (const [playerId, level] of this.authorizedPlayers) {
      players.push({ playerId, level, isOwner: playerId === this.ownerId });
    }
    return players;
  }

  /**
   * Deposit resources for upkeep
   * @param {Object} resources - Resources to deposit
   * @returns {Object} Deposit result
   */
  depositResources(resources) {
    const deposited = {};
    const rejected = {};

    for (const [type, amount] of Object.entries(resources)) {
      if (amount <= 0) continue;

      const current = this.resources.get(type) ?? 0;
      const max = this.maxStorage[type] ?? 0;

      if (max === 0) {
        rejected[type] = { amount, reason: 'Resource type not accepted' };
        continue;
      }

      const canDeposit = Math.min(amount, max - current);

      if (canDeposit > 0) {
        this.resources.set(type, current + canDeposit);
        deposited[type] = canDeposit;
      }

      if (canDeposit < amount) {
        rejected[type] = { 
          amount: amount - canDeposit, 
          reason: 'Storage full' 
        };
      }
    }

    if (Object.keys(deposited).length > 0 && this.onResourcesChanged) {
      this.onResourcesChanged('deposit', deposited);
    }

    return { 
      deposited, 
      rejected: Object.keys(rejected).length > 0 ? rejected : null,
      storage: this.getResourceStatus() 
    };
  }

  /**
   * Withdraw resources from storage
   * @param {Object} resources - Resources to withdraw
   * @param {string} playerId - Player withdrawing
   * @returns {Object} Withdrawal result
   */
  withdrawResources(resources, playerId) {
    if (!this.isAuthorized(playerId, AuthLevel.BUILD)) {
      return { success: false, reason: 'Not authorized' };
    }

    const withdrawn = {};
    const insufficient = {};

    for (const [type, amount] of Object.entries(resources)) {
      if (amount <= 0) continue;

      const current = this.resources.get(type) ?? 0;
      const canWithdraw = Math.min(amount, current);

      if (canWithdraw > 0) {
        this.resources.set(type, current - canWithdraw);
        withdrawn[type] = canWithdraw;
      }

      if (canWithdraw < amount) {
        insufficient[type] = amount - canWithdraw;
      }
    }

    if (Object.keys(withdrawn).length > 0 && this.onResourcesChanged) {
      this.onResourcesChanged('withdraw', withdrawn);
    }

    return { 
      withdrawn, 
      insufficient: Object.keys(insufficient).length > 0 ? insufficient : null,
      storage: this.getResourceStatus() 
    };
  }

  /**
   * Get current resource storage status
   * @returns {Object} Resource status
   */
  getResourceStatus() {
    const status = {};

    for (const type of Object.keys(this.maxStorage)) {
      const current = this.resources.get(type) ?? 0;
      const max = this.maxStorage[type];
      status[type] = {
        current,
        max,
        percent: max > 0 ? (current / max) * 100 : 0
      };
    }

    return status;
  }

  /**
   * Get total resources as object
   * @returns {Object} Resources
   */
  getResources() {
    return Object.fromEntries(this.resources);
  }

  /**
   * Register a piece as protected
   * @param {Object} piece - Piece to register
   * @returns {boolean} Whether piece was added
   */
  registerPiece(piece) {
    if (this.contains(piece.position)) {
      this.protectedPieces.add(piece);
      return true;
    }
    return false;
  }

  /**
   * Unregister a piece
   * @param {Object} piece - Piece to unregister
   */
  unregisterPiece(piece) {
    this.protectedPieces.delete(piece);
  }

  /**
   * Update protected pieces (call after position change)
   */
  updateProtectedPieces() {
    for (const piece of this.protectedPieces) {
      if (!this.contains(piece.position)) {
        this.protectedPieces.delete(piece);
      }
    }
  }

  /**
   * Get protected pieces
   * @returns {Array} Array of protected pieces
   */
  getProtectedPieces() {
    return Array.from(this.protectedPieces);
  }

  /**
   * Calculate upkeep cost for protected pieces
   * @returns {Object} Upkeep cost by resource
   */
  calculateUpkeepCost() {
    const cost = {};

    for (const piece of this.protectedPieces) {
      const pieceCost = this.getPieceUpkeepCost(piece);
      for (const [type, amount] of Object.entries(pieceCost)) {
        cost[type] = (cost[type] ?? 0) + amount;
      }
    }

    return cost;
  }

  /**
   * Get upkeep cost for a single piece
   */
  getPieceUpkeepCost(piece) {
    const costs = {
      TWIG: { wood: 1 },
      WOOD: { wood: 5 },
      STONE: { stone: 10, wood: 2 },
      METAL: { metal: 5, stone: 5 },
      ARMORED: { highQuality: 2, metal: 10 }
    };

    const material = piece.material?.name?.toUpperCase() ?? 'WOOD';
    return costs[material] ?? costs.WOOD;
  }

  /**
   * Check if upkeep resources are available
   * @returns {boolean} Whether upkeep can be paid
   */
  hasUpkeep() {
    const cost = this.calculateUpkeepCost();

    for (const [type, amount] of Object.entries(cost)) {
      const available = this.resources.get(type) ?? 0;
      if (available < amount) {
        return false;
      }
    }

    return true;
  }

  /**
   * Process upkeep payment
   * @returns {Object} Payment result
   */
  processUpkeep() {
    const cost = this.calculateUpkeepCost();

    if (!this.hasUpkeep()) {
      this.upkeepPaid = false;
      
      if (this.onUpkeepFailed) {
        this.onUpkeepFailed(cost, this.getResources());
      }

      return { 
        success: false, 
        reason: 'Insufficient resources', 
        required: cost,
        available: this.getResources()
      };
    }

    // Deduct resources
    for (const [type, amount] of Object.entries(cost)) {
      const current = this.resources.get(type) ?? 0;
      this.resources.set(type, current - amount);
    }

    this.lastUpkeepTime = Date.now();
    this.upkeepPaid = true;

    if (this.onResourcesChanged) {
      this.onResourcesChanged('upkeep', cost);
    }

    return { 
      success: true, 
      cost, 
      nextUpkeep: this.getTimeUntilNextUpkeep(),
      storage: this.getResourceStatus()
    };
  }

  /**
   * Get time until next upkeep is due
   * @returns {number} Milliseconds until next upkeep
   */
  getTimeUntilNextUpkeep() {
    const elapsed = Date.now() - this.lastUpkeepTime;
    return Math.max(0, this.upkeepInterval - elapsed);
  }

  /**
   * Get time until decay starts
   * @returns {number} Milliseconds until decay begins
   */
  getTimeUntilDecay() {
    const cost = this.calculateUpkeepCost();
    let minIntervals = Infinity;

    for (const [type, amount] of Object.entries(cost)) {
      if (amount === 0) continue;

      const available = this.resources.get(type) ?? 0;
      const intervals = Math.floor(available / amount);
      minIntervals = Math.min(minIntervals, intervals);
    }

    const totalTime = minIntervals * this.upkeepInterval;
    return Math.min(totalTime, this.upkeepBuffer);
  }

  /**
   * Get comprehensive status for UI
   * @returns {Object} Full status
   */
  getStatus() {
    const cost = this.calculateUpkeepCost();

    return {
      id: this.id,
      position: { x: this.position.x, y: this.position.y, z: this.position.z },
      radius: this.radius,
      ownerId: this.ownerId,
      authorizedCount: this.authorizedPlayers.size,
      protectedPieceCount: this.protectedPieces.size,
      resources: this.getResourceStatus(),
      upkeepCost: cost,
      hasUpkeep: this.hasUpkeep(),
      upkeepPaid: this.upkeepPaid,
      timeUntilUpkeep: this.getTimeUntilNextUpkeep(),
      timeUntilDecay: this.getTimeUntilDecay(),
      lastUpkeepTime: this.lastUpkeepTime
    };
  }

  /**
   * Serialize for saving
   * @returns {Object} Serialized data
   */
  serialize() {
    return {
      version: 1,
      id: this.id,
      position: { x: this.position.x, y: this.position.y, z: this.position.z },
      radius: this.radius,
      ownerId: this.ownerId,
      authorizedPlayers: Array.from(this.authorizedPlayers.entries()),
      resources: Array.from(this.resources.entries()),
      lastUpkeepTime: this.lastUpkeepTime,
      upkeepPaid: this.upkeepPaid,
      protectedPieceIds: Array.from(this.protectedPieces).map(p => p.id)
    };
  }

  /**
   * Deserialize from saved data
   * @param {Object} data - Saved data
   * @param {Map} pieceMap - Map of piece IDs to pieces
   * @returns {ToolCupboard} Restored instance
   */
  static deserialize(data, pieceMap = new Map()) {
    const tc = new ToolCupboard({
      id: data.id,
      position: new THREE.Vector3(data.position.x, data.position.y, data.position.z),
      radius: data.radius,
      ownerId: data.ownerId
    });

    tc.authorizedPlayers = new Map(data.authorizedPlayers);
    tc.resources = new Map(data.resources);
    tc.lastUpkeepTime = data.lastUpkeepTime;
    tc.upkeepPaid = data.upkeepPaid;

    // Restore piece references
    for (const pieceId of data.protectedPieceIds) {
      const piece = pieceMap.get(pieceId);
      if (piece) {
        tc.protectedPieces.add(piece);
      }
    }

    return tc;
  }
}

export default ToolCupboard;

/**
 * UpkeepSystem - Manages upkeep calculations and resource scaling
 * 
 * Implements Rust-style upkeep scaling where larger bases cost
 * progressively more resources to maintain.
 * 
 * Usage:
 *   const upkeep = new UpkeepSystem({ scalingMode: 'exponential' });
 *   const cost = upkeep.calculateScaledUpkeep(toolCupboard);
 *   const preview = upkeep.previewAddition(toolCupboard, newPieces);
 */

/**
 * Scaling modes for upkeep costs
 */
export const ScalingMode = {
  LINEAR: 'linear',           // Constant cost per piece
  EXPONENTIAL: 'exponential', // Rust-style brackets
  LOGARITHMIC: 'logarithmic', // Slower scaling for casual games
  FLAT: 'flat'                // No scaling
};

/**
 * Default upkeep costs per piece by material
 */
export const DefaultUpkeepCosts = {
  TWIG: { wood: 1 },
  WOOD: { wood: 5 },
  STONE: { stone: 10, wood: 2 },
  METAL: { metal: 5, stone: 5 },
  ARMORED: { highQuality: 2, metal: 10 },
  THATCH: { thatch: 5, fiber: 2 }
};

/**
 * Default scaling brackets (Rust-inspired)
 */
export const DefaultBrackets = [
  { pieces: 15, multiplier: 1.0 },
  { pieces: 50, multiplier: 1.5 },
  { pieces: 100, multiplier: 2.0 },
  { pieces: 200, multiplier: 3.0 },
  { pieces: Infinity, multiplier: 5.0 }
];

export class UpkeepSystem {
  /**
   * Create upkeep system
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    this.scalingMode = options.scalingMode ?? ScalingMode.EXPONENTIAL;
    this.baseCostMultiplier = options.baseCostMultiplier ?? 1.0;
    this.brackets = options.brackets ?? DefaultBrackets;
    this.upkeepCosts = options.upkeepCosts ?? DefaultUpkeepCosts;
    this.upkeepInterval = options.upkeepInterval ?? 24 * 60 * 60 * 1000; // 24 hours
    
    // Tier ordering for bracket calculation
    this.materialTiers = options.materialTiers ?? {
      TWIG: 0, THATCH: 0,
      WOOD: 1,
      STONE: 2,
      METAL: 3,
      ARMORED: 4, TEK: 4
    };
  }

  /**
   * Calculate scaled upkeep for a protection zone
   * @param {Object} protectionZone - Tool Cupboard or equivalent
   * @returns {Object} Upkeep calculation results
   */
  calculateScaledUpkeep(protectionZone) {
    const pieces = this.getPiecesFromZone(protectionZone);
    
    if (pieces.length === 0) {
      return {
        baseCost: {},
        scaledCost: {},
        pieceCount: 0,
        scalingFactor: 1.0
      };
    }

    // Sort pieces by tier (higher tier first for bracket calculation)
    const sortedPieces = [...pieces].sort((a, b) => {
      const tierA = this.getMaterialTier(a.material);
      const tierB = this.getMaterialTier(b.material);
      return tierB - tierA;
    });

    // Calculate base cost (unscaled)
    const baseCost = this.calculateBaseCost(pieces);

    // Calculate scaled cost based on mode
    let scaledCost;
    switch (this.scalingMode) {
      case ScalingMode.EXPONENTIAL:
        scaledCost = this.calculateExponentialCost(sortedPieces);
        break;
      case ScalingMode.LINEAR:
        scaledCost = this.calculateLinearCost(pieces);
        break;
      case ScalingMode.LOGARITHMIC:
        scaledCost = this.calculateLogarithmicCost(pieces);
        break;
      case ScalingMode.FLAT:
      default:
        scaledCost = { ...baseCost };
    }

    // Apply base multiplier
    for (const resource of Object.keys(scaledCost)) {
      scaledCost[resource] = Math.ceil(scaledCost[resource] * this.baseCostMultiplier);
    }

    return {
      baseCost,
      scaledCost,
      pieceCount: pieces.length,
      scalingFactor: this.calculateAverageScaling(pieces.length),
      perInterval: this.upkeepInterval,
      perHour: this.calculatePerHour(scaledCost)
    };
  }

  /**
   * Get pieces from protection zone
   */
  getPiecesFromZone(zone) {
    if (zone.protectedPieces instanceof Set) {
      return Array.from(zone.protectedPieces);
    }
    if (Array.isArray(zone.protectedPieces)) {
      return zone.protectedPieces;
    }
    if (typeof zone.getProtectedPieces === 'function') {
      return zone.getProtectedPieces();
    }
    return [];
  }

  /**
   * Calculate base (unscaled) upkeep cost
   */
  calculateBaseCost(pieces) {
    const cost = {};

    for (const piece of pieces) {
      const pieceCost = this.getPieceUpkeepCost(piece);
      for (const [resource, amount] of Object.entries(pieceCost)) {
        cost[resource] = (cost[resource] ?? 0) + amount;
      }
    }

    return cost;
  }

  /**
   * Calculate exponential (bracket-based) cost
   */
  calculateExponentialCost(sortedPieces) {
    const cost = {};
    let pieceIndex = 0;

    for (const piece of sortedPieces) {
      const multiplier = this.getBracketMultiplier(pieceIndex);
      const pieceCost = this.getPieceUpkeepCost(piece);

      for (const [resource, amount] of Object.entries(pieceCost)) {
        cost[resource] = (cost[resource] ?? 0) + (amount * multiplier);
      }

      pieceIndex++;
    }

    // Round up
    for (const resource of Object.keys(cost)) {
      cost[resource] = Math.ceil(cost[resource]);
    }

    return cost;
  }

  /**
   * Calculate linear cost (constant multiplier)
   */
  calculateLinearCost(pieces) {
    const cost = this.calculateBaseCost(pieces);
    const multiplier = 1 + (pieces.length * 0.01); // 1% increase per piece

    for (const resource of Object.keys(cost)) {
      cost[resource] = Math.ceil(cost[resource] * multiplier);
    }

    return cost;
  }

  /**
   * Calculate logarithmic cost (slower scaling)
   */
  calculateLogarithmicCost(pieces) {
    const cost = this.calculateBaseCost(pieces);
    const multiplier = 1 + Math.log10(Math.max(1, pieces.length));

    for (const resource of Object.keys(cost)) {
      cost[resource] = Math.ceil(cost[resource] * multiplier);
    }

    return cost;
  }

  /**
   * Get upkeep cost for a single piece
   */
  getPieceUpkeepCost(piece) {
    const materialName = piece.material?.name?.toUpperCase() ?? 'WOOD';
    return this.upkeepCosts[materialName] ?? this.upkeepCosts.WOOD ?? { wood: 1 };
  }

  /**
   * Get material tier for sorting
   */
  getMaterialTier(material) {
    const name = material?.name?.toUpperCase() ?? 'WOOD';
    return this.materialTiers[name] ?? 1;
  }

  /**
   * Get bracket multiplier for piece index
   */
  getBracketMultiplier(pieceIndex) {
    let cumulative = 0;

    for (const bracket of this.brackets) {
      if (pieceIndex < cumulative + bracket.pieces) {
        return bracket.multiplier;
      }
      cumulative += bracket.pieces;
    }

    return this.brackets[this.brackets.length - 1].multiplier;
  }

  /**
   * Calculate average scaling factor for piece count
   */
  calculateAverageScaling(totalPieces) {
    if (totalPieces === 0) return 1.0;

    let totalMultiplier = 0;
    let cumulative = 0;

    for (const bracket of this.brackets) {
      const bracketEnd = Math.min(cumulative + bracket.pieces, totalPieces);
      const piecesInBracket = Math.max(0, bracketEnd - cumulative);

      totalMultiplier += piecesInBracket * bracket.multiplier;
      cumulative = bracketEnd;

      if (cumulative >= totalPieces) break;
    }

    return totalMultiplier / totalPieces;
  }

  /**
   * Calculate per-hour resource drain
   */
  calculatePerHour(cost) {
    const hoursPerInterval = this.upkeepInterval / (60 * 60 * 1000);
    const perHour = {};

    for (const [resource, amount] of Object.entries(cost)) {
      perHour[resource] = amount / hoursPerInterval;
    }

    return perHour;
  }

  /**
   * Preview upkeep cost for adding pieces
   * @param {Object} protectionZone - Current protection zone
   * @param {Array} newPieces - Pieces to add
   * @returns {Object} Preview of cost changes
   */
  previewAddition(protectionZone, newPieces) {
    const currentPieces = this.getPiecesFromZone(protectionZone);
    const currentCost = this.calculateScaledUpkeep(protectionZone);

    // Create temporary zone with new pieces
    const combinedPieces = [...currentPieces, ...newPieces];
    const tempZone = {
      protectedPieces: combinedPieces
    };

    const newCost = this.calculateScaledUpkeep(tempZone);

    // Calculate increase
    const increase = {};
    const allResources = new Set([
      ...Object.keys(currentCost.scaledCost),
      ...Object.keys(newCost.scaledCost)
    ]);

    for (const resource of allResources) {
      const current = currentCost.scaledCost[resource] ?? 0;
      const updated = newCost.scaledCost[resource] ?? 0;
      increase[resource] = updated - current;
    }

    return {
      currentCost: currentCost.scaledCost,
      newCost: newCost.scaledCost,
      increase,
      currentPieceCount: currentPieces.length,
      newPieceCount: combinedPieces.length,
      piecesAdded: newPieces.length,
      currentScaling: currentCost.scalingFactor,
      newScaling: newCost.scalingFactor
    };
  }

  /**
   * Preview upkeep cost for removing pieces
   */
  previewRemoval(protectionZone, piecesToRemove) {
    const currentPieces = this.getPiecesFromZone(protectionZone);
    const currentCost = this.calculateScaledUpkeep(protectionZone);

    // Create set of IDs to remove
    const removeIds = new Set(piecesToRemove.map(p => p.id));
    const remainingPieces = currentPieces.filter(p => !removeIds.has(p.id));

    const tempZone = {
      protectedPieces: remainingPieces
    };

    const newCost = this.calculateScaledUpkeep(tempZone);

    // Calculate savings
    const savings = {};
    for (const resource of Object.keys(currentCost.scaledCost)) {
      const current = currentCost.scaledCost[resource] ?? 0;
      const updated = newCost.scaledCost[resource] ?? 0;
      savings[resource] = current - updated;
    }

    return {
      currentCost: currentCost.scaledCost,
      newCost: newCost.scaledCost,
      savings,
      currentPieceCount: currentPieces.length,
      newPieceCount: remainingPieces.length,
      piecesRemoved: piecesToRemove.length
    };
  }

  /**
   * Calculate time until resources run out
   * @param {Object} protectionZone - Protection zone with resources
   * @returns {Object} Time calculations
   */
  calculateTimeUntilEmpty(protectionZone) {
    const cost = this.calculateScaledUpkeep(protectionZone);
    const resources = this.getResourcesFromZone(protectionZone);

    let minIntervals = Infinity;
    let limitingResource = null;

    for (const [resource, needed] of Object.entries(cost.scaledCost)) {
      if (needed === 0) continue;

      const available = resources[resource] ?? 0;
      const intervals = Math.floor(available / needed);

      if (intervals < minIntervals) {
        minIntervals = intervals;
        limitingResource = resource;
      }
    }

    const timeMs = minIntervals * this.upkeepInterval;

    return {
      intervals: minIntervals,
      timeMs,
      timeFormatted: this.formatTime(timeMs),
      limitingResource,
      resourceStatus: this.getResourceStatus(protectionZone, cost.scaledCost)
    };
  }

  /**
   * Get resources from protection zone
   */
  getResourcesFromZone(zone) {
    if (zone.resources instanceof Map) {
      return Object.fromEntries(zone.resources);
    }
    if (typeof zone.getResources === 'function') {
      return zone.getResources();
    }
    return zone.resources ?? {};
  }

  /**
   * Get detailed resource status
   */
  getResourceStatus(zone, cost) {
    const resources = this.getResourcesFromZone(zone);
    const status = {};

    for (const [resource, needed] of Object.entries(cost)) {
      const available = resources[resource] ?? 0;
      const intervals = needed > 0 ? Math.floor(available / needed) : Infinity;

      status[resource] = {
        available,
        needed,
        intervals,
        sufficient: available >= needed,
        deficit: Math.max(0, needed - available)
      };
    }

    return status;
  }

  /**
   * Get upkeep breakdown by material type
   */
  getBreakdownByMaterial(protectionZone) {
    const pieces = this.getPiecesFromZone(protectionZone);
    const breakdown = {};

    for (const piece of pieces) {
      const material = piece.material?.name ?? 'Unknown';
      if (!breakdown[material]) {
        breakdown[material] = {
          count: 0,
          baseCost: {},
          scaledCost: {}
        };
      }

      breakdown[material].count++;
      const pieceCost = this.getPieceUpkeepCost(piece);

      for (const [resource, amount] of Object.entries(pieceCost)) {
        breakdown[material].baseCost[resource] = 
          (breakdown[material].baseCost[resource] ?? 0) + amount;
      }
    }

    return breakdown;
  }

  /**
   * Format time in human-readable format
   */
  formatTime(ms) {
    if (ms === Infinity || ms < 0) return 'Forever';

    const hours = ms / (60 * 60 * 1000);

    if (hours >= 24) {
      const days = Math.floor(hours / 24);
      const remainingHours = Math.floor(hours % 24);
      return `${days}d ${remainingHours}h`;
    }

    if (hours >= 1) {
      return `${Math.floor(hours)}h ${Math.floor((hours % 1) * 60)}m`;
    }

    const minutes = Math.floor(ms / (60 * 1000));
    return `${minutes}m`;
  }

  /**
   * Get scaling curve data for UI visualization
   */
  getScalingCurve(maxPieces = 300) {
    const points = [];

    for (let i = 0; i <= maxPieces; i += 5) {
      points.push({
        pieces: i,
        multiplier: this.calculateAverageScaling(i),
        bracket: this.getBracketMultiplier(i)
      });
    }

    return points;
  }

  /**
   * Update configuration
   */
  setOptions(options) {
    if (options.scalingMode !== undefined) this.scalingMode = options.scalingMode;
    if (options.baseCostMultiplier !== undefined) this.baseCostMultiplier = options.baseCostMultiplier;
    if (options.brackets !== undefined) this.brackets = options.brackets;
    if (options.upkeepInterval !== undefined) this.upkeepInterval = options.upkeepInterval;
  }
}

export default UpkeepSystem;