Structural Physics

{
  "name": "structural-physics",
  "description": "Structural validation and damage systems for Three.js building games. Use when implementing building stability, damage propagation, cascading collapse, or realistic physics simulation.",
  "tags": [
    "building-game",
    "3d",
    "code-generation"
  ],
  "sub_skills": [],
  "source": "claude-user",
  "type": "template",
  "depends_on": [],
  "enhances": [
    "3d-building-advanced",
    "decay-upkeep"
  ],
  "last_reviewed_at": null,
  "review_score": null,
  "relevance_tier": null
}

/**
 * DamagePropagation - Damage states, cascading destruction, and collapse effects
 * 
 * Implements partial damage, structural weakening, and realistic-feeling
 * cascading collapses for building systems.
 * 
 * Usage:
 *   const damageSystem = new DamageSystem(validator, optimizer);
 *   damageSystem.applyDamage(piece, 50);
 *   const result = damageSystem.destroyPiece(piece);
 *   damageSystem.update(deltaTime); // Animate collapses
 */

import * as THREE from 'three';

/**
 * Damage states for building pieces
 */
export const DamageState = {
  PRISTINE: 'pristine',     // 100-61% health
  DAMAGED: 'damaged',       // 60-26% health
  CRITICAL: 'critical',     // 25-1% health
  DESTROYED: 'destroyed'    // 0% health
};

/**
 * Damage types with different effects
 */
export const DamageType = {
  PHYSICAL: 'physical',     // Melee, bullets, projectiles
  EXPLOSIVE: 'explosive',   // Area damage, splash
  FIRE: 'fire',             // Over time, spreads
  STRUCTURAL: 'structural', // From collapse/cascade
  DECAY: 'decay'            // Over time degradation
};

/**
 * Material resistance properties
 */
export const MaterialResistance = {
  WOOD: {
    physical: 1.0,
    explosive: 1.2,
    fire: 1.5,
    structural: 1.0,
    decay: 1.2
  },
  STONE: {
    physical: 0.5,
    explosive: 0.8,
    fire: 0.2,
    structural: 0.7,
    decay: 0.5
  },
  METAL: {
    physical: 0.3,
    explosive: 0.6,
    fire: 0.1,
    structural: 0.5,
    decay: 0.3
  },
  THATCH: {
    physical: 1.5,
    explosive: 2.0,
    fire: 3.0,
    structural: 1.5,
    decay: 2.0
  }
};

/**
 * Damageable wrapper for building pieces
 */
export class DamageablePiece {
  constructor(piece, options = {}) {
    this.piece = piece;
    this.maxHealth = options.maxHealth ?? piece.material?.health ?? 100;
    this.health = this.maxHealth;
    this.damageState = DamageState.PRISTINE;
    this.damageHistory = [];
    this.onFire = false;
    this.fireIntensity = 0;
    this.decayRate = options.decayRate ?? 0;
    
    // Resistance based on material
    const materialName = piece.material?.name ?? 'WOOD';
    this.resistance = MaterialResistance[materialName] ?? MaterialResistance.WOOD;
  }

  /**
   * Apply damage with type-specific resistance
   */
  takeDamage(amount, type = DamageType.PHYSICAL, source = null) {
    const resistance = this.resistance[type] ?? 1.0;
    const actualDamage = amount * resistance;

    this.health = Math.max(0, this.health - actualDamage);
    this.updateDamageState();

    // Track damage history
    this.damageHistory.push({
      amount: actualDamage,
      type,
      source,
      timestamp: Date.now(),
      healthAfter: this.health
    });

    // Fire can spread
    if (type === DamageType.FIRE && !this.onFire && this.resistance.fire > 0.5) {
      this.onFire = true;
      this.fireIntensity = 0.3;
    }

    return {
      damageDealt: actualDamage,
      newHealth: this.health,
      newState: this.damageState,
      destroyed: this.damageState === DamageState.DESTROYED
    };
  }

  /**
   * Heal the piece
   */
  heal(amount) {
    this.health = Math.min(this.maxHealth, this.health + amount);
    this.updateDamageState();
    return this.health;
  }

  /**
   * Update damage state based on health
   */
  updateDamageState() {
    const healthPercent = this.health / this.maxHealth;

    if (healthPercent <= 0) {
      this.damageState = DamageState.DESTROYED;
    } else if (healthPercent <= 0.25) {
      this.damageState = DamageState.CRITICAL;
    } else if (healthPercent <= 0.6) {
      this.damageState = DamageState.DAMAGED;
    } else {
      this.damageState = DamageState.PRISTINE;
    }
  }

  /**
   * Get stability modifier based on damage
   */
  getStabilityModifier() {
    switch (this.damageState) {
      case DamageState.PRISTINE: return 1.0;
      case DamageState.DAMAGED: return 0.85;
      case DamageState.CRITICAL: return 0.6;
      default: return 0;
    }
  }

  /**
   * Get health percentage
   */
  getHealthPercent() {
    return this.health / this.maxHealth;
  }

  /**
   * Update fires and decay
   */
  update(deltaTime) {
    // Fire damage over time
    if (this.onFire) {
      this.fireIntensity = Math.min(1.0, this.fireIntensity + deltaTime * 0.1);
      const fireDamage = this.fireIntensity * deltaTime * 10;
      this.takeDamage(fireDamage, DamageType.FIRE);

      // Fire burns out on resistant materials
      if (this.resistance.fire < 0.3) {
        this.onFire = false;
        this.fireIntensity = 0;
      }
    }

    // Decay over time
    if (this.decayRate > 0) {
      const decayDamage = this.decayRate * deltaTime;
      this.takeDamage(decayDamage, DamageType.DECAY);
    }

    return this.damageState;
  }
}

/**
 * Collapse animation for destroyed pieces
 */
export class CollapseAnimation {
  constructor(piece, options = {}) {
    this.piece = piece;
    this.mesh = piece.mesh || piece;
    this.startTime = performance.now();
    this.delay = options.delay ?? 0;
    this.duration = options.duration ?? 800 + Math.random() * 400;
    
    // Initial state
    this.startPosition = this.mesh.position.clone();
    this.startRotation = this.mesh.rotation.clone();
    this.startScale = this.mesh.scale.clone();
    
    // Physics
    this.velocity = options.velocity ?? new THREE.Vector3(
      (Math.random() - 0.5) * 3,
      Math.random() * 2 - 1,
      (Math.random() - 0.5) * 3
    );
    this.angularVelocity = new THREE.Vector3(
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4
    );
    this.gravity = options.gravity ?? -15;
    
    // State
    this.phase = 'waiting';
    this.progress = 0;
    this.complete = false;
  }

  /**
   * Update animation
   */
  update(deltaTime) {
    const elapsed = performance.now() - this.startTime;

    // Wait for delay
    if (this.phase === 'waiting') {
      if (elapsed >= this.delay) {
        this.phase = 'falling';
        this.fallStart = performance.now();
      }
      return false;
    }

    // Calculate progress
    const fallElapsed = performance.now() - this.fallStart;
    this.progress = Math.min(fallElapsed / this.duration, 1);
    const t = this.progress;

    // Apply physics
    const dt = t; // Normalized time
    
    // Position: initial + velocity*t + 0.5*gravity*t^2
    this.mesh.position.x = this.startPosition.x + this.velocity.x * dt * 2;
    this.mesh.position.y = this.startPosition.y + this.velocity.y * dt * 2 + 0.5 * this.gravity * dt * dt * 4;
    this.mesh.position.z = this.startPosition.z + this.velocity.z * dt * 2;

    // Rotation
    this.mesh.rotation.x = this.startRotation.x + this.angularVelocity.x * t;
    this.mesh.rotation.y = this.startRotation.y + this.angularVelocity.y * t;
    this.mesh.rotation.z = this.startRotation.z + this.angularVelocity.z * t;

    // Scale down slightly
    const scale = 1 - t * 0.3;
    this.mesh.scale.setScalar(scale);

    // Fade out
    if (this.mesh.material) {
      if (!this.mesh.material.transparent) {
        this.mesh.material = this.mesh.material.clone();
        this.mesh.material.transparent = true;
      }
      this.mesh.material.opacity = 1 - t;
    }

    // Check completion
    if (this.progress >= 1) {
      this.complete = true;
      return true;
    }

    return false;
  }

  /**
   * Get current progress (0-1)
   */
  getProgress() {
    return this.progress;
  }
}

/**
 * Main damage system
 */
export class DamageSystem {
  constructor(validator, optimizer = null, options = {}) {
    this.validator = validator;
    this.optimizer = optimizer;
    
    // Configuration
    this.cascadeDamagePercent = options.cascadeDamagePercent ?? 0.2;  // 20% damage to neighbors
    this.cascadeRadius = options.cascadeRadius ?? 2;
    this.fireSpreadChance = options.fireSpreadChance ?? 0.3;
    this.fireSpreadRadius = options.fireSpreadRadius ?? 3;
    this.collapseDelay = options.collapseDelay ?? 50;  // ms between cascade collapses
    
    // State
    this.damageables = new Map();  // pieceId -> DamageablePiece
    this.activeCollapses = [];
    this.pendingDestructions = [];
    this.scene = options.scene ?? null;
    
    // Callbacks
    this.onPieceDestroyed = options.onPieceDestroyed ?? null;
    this.onPieceDamaged = options.onPieceDamaged ?? null;
    this.onCollapseComplete = options.onCollapseComplete ?? null;
  }

  /**
   * Register a piece with the damage system
   */
  registerPiece(piece, options = {}) {
    const damageable = new DamageablePiece(piece, options);
    this.damageables.set(piece.id, damageable);
    return damageable;
  }

  /**
   * Unregister a piece
   */
  unregisterPiece(piece) {
    this.damageables.delete(piece.id);
  }

  /**
   * Get damageable for a piece
   */
  getDamageable(piece) {
    return this.damageables.get(piece.id);
  }

  /**
   * Apply damage to a piece
   */
  applyDamage(piece, amount, type = DamageType.PHYSICAL, source = null) {
    const damageable = this.getDamageable(piece);
    if (!damageable) return null;

    const result = damageable.takeDamage(amount, type, source);

    // Notify optimizer of potential stability change
    if (this.optimizer) {
      this.optimizer.queueUpdate(piece);
    }

    // Callback
    if (this.onPieceDamaged) {
      this.onPieceDamaged(piece, result);
    }

    // Handle destruction
    if (result.destroyed) {
      this.destroyPiece(piece, { damageType: type, source });
    }

    return result;
  }

  /**
   * Apply explosive damage in radius
   */
  applyExplosiveDamage(center, radius, baseDamage) {
    const affected = [];
    
    for (const [id, damageable] of this.damageables) {
      const piece = damageable.piece;
      const distance = piece.position.distanceTo(center);
      
      if (distance <= radius) {
        // Damage falls off with distance
        const falloff = 1 - (distance / radius);
        const damage = baseDamage * falloff * falloff;
        
        const result = this.applyDamage(piece, damage, DamageType.EXPLOSIVE, center);
        affected.push({ piece, result, distance });
      }
    }

    return affected;
  }

  /**
   * Destroy a piece and handle cascading effects
   */
  destroyPiece(piece, options = {}) {
    const damageable = this.getDamageable(piece);
    
    const result = {
      destroyed: piece,
      collapsed: [],
      damaged: [],
      animations: []
    };

    // Start collapse animation for destroyed piece
    if (piece.mesh || piece instanceof THREE.Object3D) {
      const anim = new CollapseAnimation(piece, { delay: 0 });
      this.activeCollapses.push(anim);
      result.animations.push(anim);
    }

    // Find structurally unstable pieces
    const unstable = this.validator.removePiece(piece);
    
    // Queue unstable pieces for collapse with staggered delay
    for (let i = 0; i < unstable.length; i++) {
      const unstablePiece = unstable[i];
      
      this.pendingDestructions.push({
        piece: unstablePiece,
        delay: (i + 1) * this.collapseDelay,
        timestamp: performance.now(),
        cause: 'structural'
      });
    }

    result.collapsed = unstable;

    // Apply cascade damage to neighbors
    const neighbors = this.findNeighbors(piece, this.cascadeRadius);
    for (const neighbor of neighbors) {
      if (neighbor === piece || unstable.includes(neighbor)) continue;
      
      const cascadeDamage = (damageable?.maxHealth ?? 100) * this.cascadeDamagePercent;
      const damageResult = this.applyDamage(neighbor, cascadeDamage, DamageType.STRUCTURAL, piece);
      
      if (damageResult && !damageResult.destroyed) {
        result.damaged.push({ piece: neighbor, damage: cascadeDamage });
      }
    }

    // Spread fire if piece was on fire
    if (damageable?.onFire) {
      this.spreadFire(piece.position);
    }

    // Clean up
    this.unregisterPiece(piece);

    // Callback
    if (this.onPieceDestroyed) {
      this.onPieceDestroyed(piece, result);
    }

    return result;
  }

  /**
   * Find neighboring pieces within radius
   */
  findNeighbors(piece, radius) {
    const neighbors = [];
    const position = piece.position;

    for (const [id, damageable] of this.damageables) {
      if (damageable.piece === piece) continue;
      
      const dist = damageable.piece.position.distanceTo(position);
      if (dist <= radius) {
        neighbors.push(damageable.piece);
      }
    }

    return neighbors;
  }

  /**
   * Spread fire from a position
   */
  spreadFire(position) {
    const nearby = this.findNeighbors({ position }, this.fireSpreadRadius);

    for (const piece of nearby) {
      const damageable = this.getDamageable(piece);
      if (!damageable || damageable.onFire) continue;

      // Chance to catch fire based on material
      if (Math.random() < this.fireSpreadChance * damageable.resistance.fire) {
        damageable.onFire = true;
        damageable.fireIntensity = 0.2;
      }
    }
  }

  /**
   * Update damage system - call every frame
   */
  update(deltaTime) {
    const now = performance.now();

    // Update damageable pieces (fire, decay)
    for (const [id, damageable] of this.damageables) {
      damageable.update(deltaTime);
    }

    // Process pending destructions
    for (let i = this.pendingDestructions.length - 1; i >= 0; i--) {
      const pending = this.pendingDestructions[i];
      
      if (now - pending.timestamp >= pending.delay) {
        this.pendingDestructions.splice(i, 1);
        
        // Create collapse animation
        const piece = pending.piece;
        if (piece.mesh || piece instanceof THREE.Object3D) {
          const anim = new CollapseAnimation(piece, {
            delay: 0,
            velocity: new THREE.Vector3(
              (Math.random() - 0.5) * 2,
              Math.random() * -2,
              (Math.random() - 0.5) * 2
            )
          });
          this.activeCollapses.push(anim);
        }

        // Clean up
        this.unregisterPiece(piece);
        this.validator.removePiece(piece);
      }
    }

    // Update collapse animations
    for (let i = this.activeCollapses.length - 1; i >= 0; i--) {
      const anim = this.activeCollapses[i];
      const complete = anim.update(deltaTime);

      if (complete) {
        this.activeCollapses.splice(i, 1);
        
        // Remove from scene
        if (this.scene && anim.mesh.parent) {
          anim.mesh.parent.remove(anim.mesh);
        }

        // Callback
        if (this.onCollapseComplete) {
          this.onCollapseComplete(anim.piece);
        }
      }
    }
  }

  /**
   * Get all pieces on fire
   */
  getBurningPieces() {
    const burning = [];
    for (const [id, damageable] of this.damageables) {
      if (damageable.onFire) {
        burning.push(damageable.piece);
      }
    }
    return burning;
  }

  /**
   * Extinguish fires in radius
   */
  extinguishFires(position, radius) {
    let extinguished = 0;
    
    for (const [id, damageable] of this.damageables) {
      if (!damageable.onFire) continue;
      
      const dist = damageable.piece.position.distanceTo(position);
      if (dist <= radius) {
        damageable.onFire = false;
        damageable.fireIntensity = 0;
        extinguished++;
      }
    }

    return extinguished;
  }

  /**
   * Get damage statistics
   */
  getStats() {
    let totalHealth = 0;
    let totalMaxHealth = 0;
    let damagedCount = 0;
    let criticalCount = 0;
    let burningCount = 0;

    for (const [id, damageable] of this.damageables) {
      totalHealth += damageable.health;
      totalMaxHealth += damageable.maxHealth;
      
      if (damageable.damageState === DamageState.DAMAGED) damagedCount++;
      if (damageable.damageState === DamageState.CRITICAL) criticalCount++;
      if (damageable.onFire) burningCount++;
    }

    return {
      totalPieces: this.damageables.size,
      healthPercent: totalMaxHealth > 0 ? Math.round(totalHealth / totalMaxHealth * 100) : 0,
      damagedPieces: damagedCount,
      criticalPieces: criticalCount,
      burningPieces: burningCount,
      activeCollapses: this.activeCollapses.length,
      pendingDestructions: this.pendingDestructions.length
    };
  }

  /**
   * Clear all state
   */
  clear() {
    this.damageables.clear();
    this.activeCollapses = [];
    this.pendingDestructions = [];
  }
}

/**
 * Visual effects for damage states
 */
export class DamageVisualizer {
  constructor(options = {}) {
    this.colors = {
      pristine: options.pristineColor ?? null,  // Use original color
      damaged: options.damagedColor ?? new THREE.Color(0xaa8866),
      critical: options.criticalColor ?? new THREE.Color(0x884422),
      fire: options.fireColor ?? new THREE.Color(0xff4400)
    };
    
    this.showCracks = options.showCracks ?? true;
    this.showSmoke = options.showSmoke ?? true;
  }

  /**
   * Update visual appearance based on damage state
   */
  updateVisuals(piece, damageable) {
    const mesh = piece.mesh || piece;
    if (!mesh.material) return;

    // Color based on state
    if (damageable.onFire) {
      this.applyFireEffect(mesh, damageable.fireIntensity);
    } else {
      switch (damageable.damageState) {
        case DamageState.DAMAGED:
          this.applyDamageColor(mesh, this.colors.damaged, 0.3);
          break;
        case DamageState.CRITICAL:
          this.applyDamageColor(mesh, this.colors.critical, 0.6);
          break;
        default:
          this.restoreOriginalColor(mesh);
      }
    }
  }

  applyDamageColor(mesh, color, intensity) {
    if (!mesh._originalColor) {
      mesh._originalColor = mesh.material.color.clone();
    }
    mesh.material.color.copy(mesh._originalColor).lerp(color, intensity);
  }

  applyFireEffect(mesh, intensity) {
    if (!mesh._originalColor) {
      mesh._originalColor = mesh.material.color.clone();
    }
    
    // Flickering fire effect
    const flicker = 0.8 + Math.random() * 0.2;
    const fireColor = this.colors.fire.clone().multiplyScalar(flicker);
    mesh.material.color.copy(mesh._originalColor).lerp(fireColor, intensity * 0.5);
    
    // Emissive glow
    if (mesh.material.emissive) {
      mesh.material.emissive.copy(fireColor).multiplyScalar(intensity * 0.3);
    }
  }

  restoreOriginalColor(mesh) {
    if (mesh._originalColor) {
      mesh.material.color.copy(mesh._originalColor);
      if (mesh.material.emissive) {
        mesh.material.emissive.setScalar(0);
      }
    }
  }
}

export default DamageSystem;

/**
 * HeuristicValidator - Fast stability validation for building systems
 * 
 * Implements both arcade (connectivity-only) and heuristic (stability percentage)
 * approaches used by games like Fortnite, Rust, and Valheim.
 * 
 * Usage:
 *   const validator = new HeuristicValidator({ mode: 'heuristic' });
 *   validator.addPiece(piece);
 *   const canPlace = validator.validatePlacement(newPiece);
 *   const unstable = validator.onPieceDestroyed(piece);
 */

import * as THREE from 'three';

/**
 * Support relationship types
 */
export const SupportType = {
  GROUND: 'ground',         // Directly on terrain
  FOUNDATION: 'foundation', // On a foundation piece
  VERTICAL: 'vertical',     // Wall/pillar support
  HORIZONTAL: 'horizontal', // Floor/ceiling support
  CANTILEVER: 'cantilever'  // Offset horizontal support
};

/**
 * Validation modes
 */
export const ValidationMode = {
  ARCADE: 'arcade',       // Connectivity only (Fortnite/Minecraft)
  HEURISTIC: 'heuristic', // Stability percentage (Rust/Valheim)
  HYBRID: 'hybrid'        // Arcade for placement, heuristic for limits
};

/**
 * Material presets with stability properties
 */
export const MaterialPresets = {
  WOOD: {
    name: 'Wood',
    stabilityDecay: 0.15,
    maxStability: 1.0,
    canFloat: false
  },
  STONE: {
    name: 'Stone',
    stabilityDecay: 0.10,
    maxStability: 1.0,
    canFloat: false
  },
  METAL: {
    name: 'Metal',
    stabilityDecay: 0.05,
    maxStability: 1.0,
    canFloat: false
  },
  THATCH: {
    name: 'Thatch',
    stabilityDecay: 0.20,
    maxStability: 1.0,
    canFloat: false
  },
  // Special materials
  SCAFFOLD: {
    name: 'Scaffold',
    stabilityDecay: 0.25,
    maxStability: 0.5,
    canFloat: true // Can be placed without support
  }
};

/**
 * Support graph for tracking piece relationships
 */
export class SupportGraph {
  constructor() {
    this.pieces = new Map();        // id -> piece
    this.supports = new Map();      // id -> Set<piece> (pieces this supports)
    this.supportedBy = new Map();   // id -> Set<piece> (pieces supporting this)
    this.groundedPieces = new Set(); // Pieces directly on ground
  }

  addPiece(piece) {
    this.pieces.set(piece.id, piece);
    this.supports.set(piece.id, new Set());
    this.supportedBy.set(piece.id, new Set());

    if (piece.isGrounded) {
      this.groundedPieces.add(piece.id);
    }
  }

  removePiece(piece) {
    const id = piece.id;

    // Remove from supporters' support lists
    for (const supporter of this.supportedBy.get(id) || []) {
      this.supports.get(supporter.id)?.delete(piece);
    }

    // Remove from supported pieces' supportedBy lists
    for (const supported of this.supports.get(id) || []) {
      this.supportedBy.get(supported.id)?.delete(piece);
    }

    this.pieces.delete(id);
    this.supports.delete(id);
    this.supportedBy.delete(id);
    this.groundedPieces.delete(id);
  }

  addSupportRelation(supporter, supported) {
    this.supports.get(supporter.id)?.add(supported);
    this.supportedBy.get(supported.id)?.add(supporter);
  }

  removeSupportRelation(supporter, supported) {
    this.supports.get(supporter.id)?.delete(supported);
    this.supportedBy.get(supported.id)?.delete(supporter);
  }

  getSupports(piece) {
    return Array.from(this.supportedBy.get(piece.id) || []);
  }

  getSupportedPieces(piece) {
    return Array.from(this.supports.get(piece.id) || []);
  }

  isGrounded(piece) {
    return this.groundedPieces.has(piece.id);
  }

  /**
   * Check if piece has path to any grounded piece (BFS)
   */
  hasPathToGround(piece) {
    if (this.isGrounded(piece)) return true;

    const visited = new Set();
    const queue = [piece];

    while (queue.length > 0) {
      const current = queue.shift();
      if (visited.has(current.id)) continue;
      visited.add(current.id);

      if (this.isGrounded(current)) return true;

      for (const supporter of this.getSupports(current)) {
        if (!visited.has(supporter.id)) {
          queue.push(supporter);
        }
      }
    }

    return false;
  }

  /**
   * Find all pieces that would be disconnected if piece is removed
   */
  findDisconnectedAfterRemoval(piece) {
    // Temporarily remove piece
    const supporters = this.getSupports(piece);
    const supported = this.getSupportedPieces(piece);

    // Find all pieces that might be affected
    const potentiallyAffected = new Set();
    const queue = [...supported];

    while (queue.length > 0) {
      const current = queue.shift();
      if (current === piece || potentiallyAffected.has(current)) continue;
      potentiallyAffected.add(current);

      for (const s of this.getSupportedPieces(current)) {
        queue.push(s);
      }
    }

    // Check which affected pieces would lose ground connection
    const disconnected = [];
    for (const affected of potentiallyAffected) {
      if (!this.hasPathToGroundExcluding(affected, piece)) {
        disconnected.push(affected);
      }
    }

    return disconnected;
  }

  hasPathToGroundExcluding(piece, excluded) {
    if (piece === excluded) return false;
    if (this.isGrounded(piece)) return true;

    const visited = new Set([excluded.id]);
    const queue = [piece];

    while (queue.length > 0) {
      const current = queue.shift();
      if (visited.has(current.id)) continue;
      visited.add(current.id);

      if (this.isGrounded(current)) return true;

      for (const supporter of this.getSupports(current)) {
        if (!visited.has(supporter.id)) {
          queue.push(supporter);
        }
      }
    }

    return false;
  }

  getAllPieces() {
    return Array.from(this.pieces.values());
  }

  clear() {
    this.pieces.clear();
    this.supports.clear();
    this.supportedBy.clear();
    this.groundedPieces.clear();
  }
}

/**
 * Main validator class
 */
export class HeuristicValidator {
  constructor(options = {}) {
    this.mode = options.mode ?? ValidationMode.HEURISTIC;
    this.minStability = options.minStability ?? 0.05;
    this.snapTolerance = options.snapTolerance ?? 0.15;
    this.defaultMaterial = options.defaultMaterial ?? MaterialPresets.WOOD;

    this.graph = new SupportGraph();
    this.stabilityCache = new Map();
    this.dirtyPieces = new Set();
  }

  /**
   * Add a piece to the system
   */
  addPiece(piece, detectSupports = true) {
    // Ensure piece has required properties
    piece.material = piece.material ?? this.defaultMaterial;
    piece.isGrounded = piece.isGrounded ?? this.detectGrounded(piece);

    this.graph.addPiece(piece);

    if (detectSupports) {
      this.detectAndAddSupports(piece);
    }

    this.invalidateStability(piece);
    return piece;
  }

  /**
   * Remove a piece and handle collapse
   */
  removePiece(piece) {
    // Find pieces that will collapse
    const toCollapse = this.mode === ValidationMode.ARCADE
      ? this.graph.findDisconnectedAfterRemoval(piece)
      : this.findUnstableAfterRemoval(piece);

    // Remove the piece
    this.graph.removePiece(piece);
    this.stabilityCache.delete(piece.id);

    // Invalidate affected pieces
    for (const p of toCollapse) {
      this.invalidateStability(p);
    }

    return toCollapse;
  }

  /**
   * Validate if a piece can be placed
   */
  validatePlacement(piece) {
    const result = {
      valid: false,
      stability: 0,
      reason: null,
      supports: []
    };

    // Check for overlaps (would need spatial index in real impl)
    // Skipped here - assumed handled by collision system

    // Find potential supports
    const supports = this.findPotentialSupports(piece);
    result.supports = supports;

    // Mode-specific validation
    if (this.mode === ValidationMode.ARCADE) {
      // Arcade: just need connection to something grounded
      if (piece.isGrounded || this.detectGrounded(piece)) {
        result.valid = true;
        result.stability = 1.0;
      } else if (supports.length > 0) {
        // Check if any support has path to ground
        for (const support of supports) {
          if (this.graph.hasPathToGround(support)) {
            result.valid = true;
            result.stability = 1.0;
            break;
          }
        }
        if (!result.valid) {
          result.reason = 'No connection to ground';
        }
      } else {
        result.reason = 'No support found';
      }
    } else {
      // Heuristic: calculate stability
      const stability = this.calculateStabilityForPlacement(piece, supports);
      result.stability = stability;

      if (stability >= this.minStability) {
        result.valid = true;
      } else if (stability > 0) {
        result.reason = `Stability too low (${Math.round(stability * 100)}%)`;
      } else {
        result.reason = 'No support found';
      }
    }

    // Special material handling
    if (!result.valid && piece.material.canFloat) {
      result.valid = true;
      result.stability = piece.material.maxStability;
      result.reason = null;
    }

    return result;
  }

  /**
   * Get stability of a piece
   */
  getStability(piece) {
    if (this.mode === ValidationMode.ARCADE) {
      return this.graph.hasPathToGround(piece) ? 1.0 : 0;
    }

    if (this.stabilityCache.has(piece.id) && !this.dirtyPieces.has(piece.id)) {
      return this.stabilityCache.get(piece.id);
    }

    const stability = this.calculateStability(piece);
    this.stabilityCache.set(piece.id, stability);
    this.dirtyPieces.delete(piece.id);
    return stability;
  }

  /**
   * Calculate stability for existing piece
   */
  calculateStability(piece) {
    // Grounded pieces are always 100%
    if (this.graph.isGrounded(piece)) {
      return 1.0;
    }

    const supports = this.graph.getSupports(piece);
    if (supports.length === 0) {
      return piece.material.canFloat ? piece.material.maxStability : 0;
    }

    // Find best supporter stability
    let maxSupportStability = 0;
    for (const supporter of supports) {
      const supporterStability = this.getStability(supporter);
      maxSupportStability = Math.max(maxSupportStability, supporterStability);
    }

    // Apply decay
    const decay = this.getDecayRate(piece);
    return Math.max(0, maxSupportStability - decay);
  }

  /**
   * Calculate stability for piece not yet in graph
   */
  calculateStabilityForPlacement(piece, supports) {
    if (this.detectGrounded(piece)) {
      return 1.0;
    }

    if (supports.length === 0) {
      return piece.material.canFloat ? piece.material.maxStability : 0;
    }

    let maxSupportStability = 0;
    for (const supporter of supports) {
      const supporterStability = this.getStability(supporter);
      maxSupportStability = Math.max(maxSupportStability, supporterStability);
    }

    const decay = this.getDecayRate(piece);
    return Math.max(0, maxSupportStability - decay);
  }

  /**
   * Get decay rate for a piece
   */
  getDecayRate(piece) {
    const baseDecay = piece.material.stabilityDecay;

    // Vertical pieces (walls, pillars) decay less
    const isVertical = piece.type === 'wall' || piece.type === 'pillar';
    const orientationMod = isVertical ? 0.6 : 1.0;

    // Cantilever penalty
    const isCantilever = piece.supportType === SupportType.CANTILEVER;
    const cantileverMod = isCantilever ? 1.5 : 1.0;

    return baseDecay * orientationMod * cantileverMod;
  }

  /**
   * Find unstable pieces after a removal
   */
  findUnstableAfterRemoval(piece) {
    const affected = this.getAffectedPieces(piece);
    const unstable = [];

    // Temporarily mark piece for exclusion
    const originalSupports = this.graph.getSupports(piece);
    const originalSupported = this.graph.getSupportedPieces(piece);

    // Remove support relationships temporarily
    for (const s of originalSupported) {
      this.graph.removeSupportRelation(piece, s);
    }

    // Check stability of affected pieces
    for (const p of affected) {
      this.stabilityCache.delete(p.id);
      const stability = this.calculateStability(p);
      if (stability < this.minStability) {
        unstable.push(p);
      }
    }

    // Restore relationships
    for (const s of originalSupported) {
      this.graph.addSupportRelation(piece, s);
    }

    // Restore cache
    for (const p of affected) {
      this.stabilityCache.delete(p.id);
    }

    return unstable;
  }

  /**
   * Get all pieces affected by changes to a piece
   */
  getAffectedPieces(piece) {
    const affected = new Set();
    const queue = [...this.graph.getSupportedPieces(piece)];

    while (queue.length > 0) {
      const current = queue.shift();
      if (affected.has(current)) continue;
      affected.add(current);

      for (const supported of this.graph.getSupportedPieces(current)) {
        queue.push(supported);
      }
    }

    return Array.from(affected);
  }

  /**
   * Detect if piece is on ground
   */
  detectGrounded(piece) {
    if (piece.type !== 'foundation') return false;

    // Check if bottom of piece is at or below ground level
    const bottomY = piece.bounds?.min?.y ?? piece.position.y;
    return bottomY <= this.snapTolerance;
  }

  /**
   * Find potential support pieces for placement
   */
  findPotentialSupports(piece) {
    const supports = [];
    const pieceBounds = piece.bounds ?? this.estimateBounds(piece);

    for (const other of this.graph.getAllPieces()) {
      if (this.canSupport(other, piece, pieceBounds)) {
        supports.push(other);
      }
    }

    return supports;
  }

  /**
   * Check if one piece can support another
   */
  canSupport(supporter, piece, pieceBounds) {
    const supporterBounds = supporter.bounds ?? this.estimateBounds(supporter);
    pieceBounds = pieceBounds ?? this.estimateBounds(piece);

    // Supporter must be at or below piece
    if (supporterBounds.max.y < pieceBounds.min.y - this.snapTolerance) {
      return false;
    }

    // Vertical gap must be within tolerance
    const verticalGap = pieceBounds.min.y - supporterBounds.max.y;
    if (verticalGap > this.snapTolerance) {
      return false;
    }

    // Check horizontal overlap
    const overlapX = supporterBounds.max.x > pieceBounds.min.x - this.snapTolerance &&
                     supporterBounds.min.x < pieceBounds.max.x + this.snapTolerance;
    const overlapZ = supporterBounds.max.z > pieceBounds.min.z - this.snapTolerance &&
                     supporterBounds.min.z < pieceBounds.max.z + this.snapTolerance;

    return overlapX && overlapZ;
  }

  /**
   * Detect and add support relationships for a piece
   */
  detectAndAddSupports(piece) {
    const supports = this.findPotentialSupports(piece);

    for (const supporter of supports) {
      this.graph.addSupportRelation(supporter, piece);
      piece.supportType = this.determineSupportType(supporter, piece);
    }
  }

  /**
   * Determine the type of support relationship
   */
  determineSupportType(supporter, piece) {
    if (this.graph.isGrounded(supporter)) {
      return SupportType.GROUND;
    }

    if (supporter.type === 'foundation') {
      return SupportType.FOUNDATION;
    }

    if (supporter.type === 'wall' || supporter.type === 'pillar') {
      return SupportType.VERTICAL;
    }

    // Check if piece is centered over supporter
    const dx = Math.abs(supporter.position.x - piece.position.x);
    const dz = Math.abs(supporter.position.z - piece.position.z);
    const offset = dx + dz;

    if (offset < 0.5) {
      return SupportType.HORIZONTAL;
    }

    return SupportType.CANTILEVER;
  }

  /**
   * Estimate bounds for piece without explicit bounds
   */
  estimateBounds(piece) {
    const size = piece.size ?? new THREE.Vector3(1, 1, 1);
    const halfSize = size.clone().multiplyScalar(0.5);
    const pos = piece.position ?? new THREE.Vector3();

    return {
      min: new THREE.Vector3().subVectors(pos, halfSize),
      max: new THREE.Vector3().addVectors(pos, halfSize)
    };
  }

  /**
   * Invalidate stability cache for piece and dependents
   */
  invalidateStability(piece) {
    this.dirtyPieces.add(piece.id);
    this.stabilityCache.delete(piece.id);

    const affected = this.getAffectedPieces(piece);
    for (const p of affected) {
      this.dirtyPieces.add(p.id);
      this.stabilityCache.delete(p.id);
    }
  }

  /**
   * Recalculate all dirty stability values
   */
  recalculateDirty() {
    const dirty = Array.from(this.dirtyPieces)
      .map(id => this.graph.pieces.get(id))
      .filter(p => p)
      .sort((a, b) => a.position.y - b.position.y); // Bottom up

    for (const piece of dirty) {
      this.getStability(piece);
    }

    this.dirtyPieces.clear();
  }

  /**
   * Get all pieces with stability below threshold
   */
  findUnstablePieces(threshold = null) {
    threshold = threshold ?? this.minStability;
    const unstable = [];

    for (const piece of this.graph.getAllPieces()) {
      const stability = this.getStability(piece);
      if (stability < threshold) {
        unstable.push({ piece, stability });
      }
    }

    return unstable;
  }

  /**
   * Set validation mode
   */
  setMode(mode) {
    this.mode = mode;
    // Clear cache when mode changes
    this.stabilityCache.clear();
    this.dirtyPieces.clear();
  }

  /**
   * Get statistics
   */
  getStats() {
    const pieces = this.graph.getAllPieces();
    let totalStability = 0;
    let minStability = Infinity;
    let maxStability = 0;
    let groundedCount = 0;

    for (const piece of pieces) {
      const stability = this.getStability(piece);
      totalStability += stability;
      minStability = Math.min(minStability, stability);
      maxStability = Math.max(maxStability, stability);
      if (this.graph.isGrounded(piece)) groundedCount++;
    }

    return {
      totalPieces: pieces.length,
      groundedPieces: groundedCount,
      avgStability: pieces.length > 0 ? totalStability / pieces.length : 0,
      minStability: minStability === Infinity ? 0 : minStability,
      maxStability,
      cacheSize: this.stabilityCache.size,
      dirtyCount: this.dirtyPieces.size,
      mode: this.mode
    };
  }

  /**
   * Clear all data
   */
  clear() {
    this.graph.clear();
    this.stabilityCache.clear();
    this.dirtyPieces.clear();
  }
}

export default HeuristicValidator;

/**
 * PhysicsEngineLite - Simplified realistic structural physics
 * 
 * Provides optional realistic physics simulation for building systems.
 * More computationally expensive than heuristic validation but creates
 * more emergent and realistic structural behavior.
 * 
 * Best for: Engineering sandboxes, bridge builders, educational simulations
 * NOT recommended for: Action games, real-time combat building
 * 
 * Usage:
 *   const physics = new PhysicsEngineLite();
 *   physics.addPiece(piece);
 *   physics.simulate(deltaTime);
 *   const stressed = physics.getOverstressedPieces();
 */

import * as THREE from 'three';

/**
 * Material physical properties
 */
export const PhysicalMaterials = {
  WOOD: {
    name: 'Wood',
    density: 600,           // kg/m³
    tensileStrength: 40,    // MPa (along grain)
    compressiveStrength: 30,// MPa
    shearStrength: 8,       // MPa
    elasticity: 12000,      // MPa (Young's modulus)
    failureStrain: 0.01     // 1% strain to failure
  },
  STONE: {
    name: 'Stone',
    density: 2500,
    tensileStrength: 5,     // Stone is weak in tension
    compressiveStrength: 100,
    shearStrength: 15,
    elasticity: 50000,
    failureStrain: 0.002
  },
  METAL: {
    name: 'Metal',
    density: 7800,
    tensileStrength: 400,
    compressiveStrength: 400,
    shearStrength: 250,
    elasticity: 200000,
    failureStrain: 0.02
  },
  CONCRETE: {
    name: 'Concrete',
    density: 2400,
    tensileStrength: 3,
    compressiveStrength: 30,
    shearStrength: 5,
    elasticity: 30000,
    failureStrain: 0.003
  }
};

/**
 * Force types
 */
export const ForceType = {
  GRAVITY: 'gravity',
  LOAD: 'load',           // Applied loads (players, objects)
  WIND: 'wind',
  SUPPORT: 'support',     // Reaction forces
  INTERNAL: 'internal'    // Internal stress
};

/**
 * Connection between pieces
 */
export class StructuralConnection {
  constructor(pieceA, pieceB, options = {}) {
    this.pieceA = pieceA;
    this.pieceB = pieceB;
    this.type = options.type ?? 'rigid'; // rigid, pin, roller
    
    // Connection point (world space)
    this.point = options.point ?? new THREE.Vector3().addVectors(
      pieceA.position,
      pieceB.position
    ).multiplyScalar(0.5);
    
    // Strength
    this.maxTension = options.maxTension ?? 10000;  // N
    this.maxCompression = options.maxCompression ?? 10000;
    this.maxShear = options.maxShear ?? 5000;
    
    // Current state
    this.tension = 0;
    this.compression = 0;
    this.shear = 0;
    this.failed = false;
    this.strain = 0;
  }

  /**
   * Calculate stress ratio (0 = no stress, 1 = at limit)
   */
  getStressRatio() {
    const tensionRatio = this.tension / this.maxTension;
    const compressionRatio = this.compression / this.maxCompression;
    const shearRatio = this.shear / this.maxShear;
    return Math.max(tensionRatio, compressionRatio, shearRatio);
  }

  /**
   * Check if connection should fail
   */
  checkFailure() {
    if (this.failed) return true;
    
    if (this.tension > this.maxTension ||
        this.compression > this.maxCompression ||
        this.shear > this.maxShear) {
      this.failed = true;
      return true;
    }
    return false;
  }

  /**
   * Reset forces for new simulation step
   */
  reset() {
    this.tension = 0;
    this.compression = 0;
    this.shear = 0;
  }
}

/**
 * Physical piece representation
 */
export class PhysicalPiece {
  constructor(piece, material = PhysicalMaterials.WOOD) {
    this.piece = piece;
    this.material = material;
    this.id = piece.id;
    
    // Geometry
    this.position = piece.position.clone();
    this.size = piece.size?.clone() ?? new THREE.Vector3(1, 1, 1);
    this.rotation = piece.rotation?.clone() ?? new THREE.Euler();
    
    // Physical properties
    this.volume = this.size.x * this.size.y * this.size.z;
    this.mass = this.volume * material.density;
    this.centerOfMass = this.position.clone();
    
    // Cross-sectional properties (simplified)
    this.crossSectionArea = this.size.x * this.size.z;
    this.momentOfInertia = (this.size.x * Math.pow(this.size.y, 3)) / 12;
    
    // Constraints
    this.isFixed = piece.isGrounded ?? false;
    this.fixedAxes = { x: false, y: this.isFixed, z: false };
    
    // Forces and state
    this.forces = [];
    this.netForce = new THREE.Vector3();
    this.stress = { tension: 0, compression: 0, shear: 0 };
    this.strain = 0;
    this.displacement = new THREE.Vector3();
    this.velocity = new THREE.Vector3();
    
    // Connections
    this.connections = [];
    
    // Failure state
    this.failed = false;
    this.failureType = null;
  }

  /**
   * Apply a force to the piece
   */
  applyForce(force, type = ForceType.LOAD, point = null) {
    this.forces.push({
      vector: force.clone(),
      type,
      point: point?.clone() ?? this.centerOfMass.clone()
    });
  }

  /**
   * Calculate net force on piece
   */
  calculateNetForce() {
    this.netForce.set(0, 0, 0);
    
    for (const force of this.forces) {
      this.netForce.add(force.vector);
    }
    
    return this.netForce;
  }

  /**
   * Calculate internal stress
   */
  calculateStress() {
    const force = this.netForce.length();
    
    // Simplified stress calculation (axial)
    const axialStress = force / this.crossSectionArea;
    
    // Determine if tension or compression based on force direction
    if (this.netForce.y > 0) {
      this.stress.tension = axialStress;
      this.stress.compression = 0;
    } else {
      this.stress.compression = axialStress;
      this.stress.tension = 0;
    }
    
    // Shear from horizontal forces
    const horizontalForce = Math.sqrt(
      this.netForce.x * this.netForce.x +
      this.netForce.z * this.netForce.z
    );
    this.stress.shear = horizontalForce / this.crossSectionArea;
    
    return this.stress;
  }

  /**
   * Calculate strain from stress
   */
  calculateStrain() {
    const maxStress = Math.max(
      this.stress.tension,
      this.stress.compression,
      this.stress.shear
    );
    
    // Hooke's law: strain = stress / E
    this.strain = maxStress / (this.material.elasticity * 1e6);
    return this.strain;
  }

  /**
   * Check for structural failure
   */
  checkFailure() {
    if (this.failed) return true;
    
    // Check against material limits
    const tensionLimit = this.material.tensileStrength * 1e6;
    const compressionLimit = this.material.compressiveStrength * 1e6;
    const shearLimit = this.material.shearStrength * 1e6;
    
    if (this.stress.tension > tensionLimit) {
      this.failed = true;
      this.failureType = 'tension';
      return true;
    }
    
    if (this.stress.compression > compressionLimit) {
      this.failed = true;
      this.failureType = 'compression';
      return true;
    }
    
    if (this.stress.shear > shearLimit) {
      this.failed = true;
      this.failureType = 'shear';
      return true;
    }
    
    // Check strain limit
    if (this.strain > this.material.failureStrain) {
      this.failed = true;
      this.failureType = 'strain';
      return true;
    }
    
    return false;
  }

  /**
   * Get safety factor (strength / current stress)
   */
  getSafetyFactor() {
    const tensionSF = this.stress.tension > 0
      ? (this.material.tensileStrength * 1e6) / this.stress.tension
      : Infinity;
    const compressionSF = this.stress.compression > 0
      ? (this.material.compressiveStrength * 1e6) / this.stress.compression
      : Infinity;
    const shearSF = this.stress.shear > 0
      ? (this.material.shearStrength * 1e6) / this.stress.shear
      : Infinity;
    
    return Math.min(tensionSF, compressionSF, shearSF);
  }

  /**
   * Reset forces for new simulation step
   */
  resetForces() {
    this.forces = [];
    this.netForce.set(0, 0, 0);
  }
}

/**
 * Main physics engine
 */
export class PhysicsEngineLite {
  constructor(options = {}) {
    this.gravity = options.gravity ?? -9.81;
    this.windForce = options.windForce ?? new THREE.Vector3();
    this.damping = options.damping ?? 0.98;
    this.maxIterations = options.maxIterations ?? 10;
    this.convergenceThreshold = options.convergenceThreshold ?? 0.001;
    
    // State
    this.pieces = new Map();
    this.connections = [];
    this.groundLevel = options.groundLevel ?? 0;
    
    // Simulation settings
    this.timeScale = options.timeScale ?? 1;
    this.substeps = options.substeps ?? 4;
    
    // Callbacks
    this.onPieceFailed = options.onPieceFailed ?? null;
    this.onConnectionFailed = options.onConnectionFailed ?? null;
  }

  /**
   * Add a piece to the simulation
   */
  addPiece(piece, material = PhysicalMaterials.WOOD) {
    const physicalPiece = new PhysicalPiece(piece, material);
    this.pieces.set(piece.id, physicalPiece);
    return physicalPiece;
  }

  /**
   * Remove a piece from simulation
   */
  removePiece(piece) {
    const id = piece.id ?? piece;
    
    // Remove connections
    this.connections = this.connections.filter(
      conn => conn.pieceA.id !== id && conn.pieceB.id !== id
    );
    
    this.pieces.delete(id);
  }

  /**
   * Create connection between pieces
   */
  connect(pieceA, pieceB, options = {}) {
    const physA = this.pieces.get(pieceA.id ?? pieceA);
    const physB = this.pieces.get(pieceB.id ?? pieceB);
    
    if (!physA || !physB) return null;
    
    const connection = new StructuralConnection(physA, physB, options);
    this.connections.push(connection);
    
    physA.connections.push(connection);
    physB.connections.push(connection);
    
    return connection;
  }

  /**
   * Auto-detect and create connections between nearby pieces
   */
  autoConnect(tolerance = 0.2) {
    const piecesArray = Array.from(this.pieces.values());
    
    for (let i = 0; i < piecesArray.length; i++) {
      for (let j = i + 1; j < piecesArray.length; j++) {
        const a = piecesArray[i];
        const b = piecesArray[j];
        
        // Check if pieces are close enough
        const dist = a.position.distanceTo(b.position);
        const maxDist = (a.size.length() + b.size.length()) / 2 + tolerance;
        
        if (dist < maxDist) {
          // Check if not already connected
          const existing = this.connections.find(
            c => (c.pieceA === a && c.pieceB === b) ||
                 (c.pieceA === b && c.pieceB === a)
          );
          
          if (!existing) {
            this.connect(a.piece, b.piece);
          }
        }
      }
    }
  }

  /**
   * Run one simulation step
   */
  simulate(deltaTime) {
    const dt = deltaTime * this.timeScale / this.substeps;
    
    for (let step = 0; step < this.substeps; step++) {
      // Reset forces
      for (const piece of this.pieces.values()) {
        piece.resetForces();
      }
      
      for (const conn of this.connections) {
        conn.reset();
      }
      
      // Apply gravity
      this.applyGravity();
      
      // Apply wind
      if (this.windForce.lengthSq() > 0) {
        this.applyWind();
      }
      
      // Solve constraints (iterative)
      this.solveConstraints();
      
      // Calculate stresses
      this.calculateStresses();
      
      // Check for failures
      this.checkFailures();
      
      // Update positions (for dynamic simulation)
      this.updatePositions(dt);
    }
  }

  /**
   * Apply gravity to all pieces
   */
  applyGravity() {
    for (const piece of this.pieces.values()) {
      if (piece.isFixed) continue;
      
      const gravityForce = new THREE.Vector3(0, piece.mass * this.gravity, 0);
      piece.applyForce(gravityForce, ForceType.GRAVITY);
    }
  }

  /**
   * Apply wind force
   */
  applyWind() {
    for (const piece of this.pieces.values()) {
      // Wind force proportional to exposed area
      const area = piece.size.x * piece.size.y;
      const force = this.windForce.clone().multiplyScalar(area);
      piece.applyForce(force, ForceType.WIND);
    }
  }

  /**
   * Solve structural constraints iteratively
   */
  solveConstraints() {
    for (let iter = 0; iter < this.maxIterations; iter++) {
      let maxError = 0;
      
      // Process connections
      for (const conn of this.connections) {
        if (conn.failed) continue;
        
        const a = conn.pieceA;
        const b = conn.pieceB;
        
        // Calculate relative displacement
        const relPos = new THREE.Vector3().subVectors(b.position, a.position);
        const restLength = a.position.distanceTo(conn.point) + b.position.distanceTo(conn.point);
        const currentLength = relPos.length();
        
        // Calculate error
        const error = currentLength - restLength;
        maxError = Math.max(maxError, Math.abs(error));
        
        if (Math.abs(error) < this.convergenceThreshold) continue;
        
        // Calculate correction forces
        const direction = relPos.normalize();
        const stiffness = (a.material.elasticity + b.material.elasticity) * 0.5 * 1e6;
        const force = error * stiffness * 0.01;
        
        // Distribute force based on mass
        const totalMass = a.mass + b.mass;
        const aRatio = a.isFixed ? 0 : b.mass / totalMass;
        const bRatio = b.isFixed ? 0 : a.mass / totalMass;
        
        // Apply forces
        if (!a.isFixed) {
          a.applyForce(direction.clone().multiplyScalar(force * aRatio), ForceType.INTERNAL);
        }
        if (!b.isFixed) {
          b.applyForce(direction.clone().multiplyScalar(-force * bRatio), ForceType.INTERNAL);
        }
        
        // Record connection stress
        if (force > 0) {
          conn.tension = Math.abs(force);
        } else {
          conn.compression = Math.abs(force);
        }
      }
      
      // Check convergence
      if (maxError < this.convergenceThreshold) break;
    }
  }

  /**
   * Calculate stress in all pieces
   */
  calculateStresses() {
    for (const piece of this.pieces.values()) {
      piece.calculateNetForce();
      piece.calculateStress();
      piece.calculateStrain();
    }
  }

  /**
   * Check for structural failures
   */
  checkFailures() {
    const failures = {
      pieces: [],
      connections: []
    };
    
    // Check piece failures
    for (const piece of this.pieces.values()) {
      if (!piece.failed && piece.checkFailure()) {
        failures.pieces.push(piece);
        
        if (this.onPieceFailed) {
          this.onPieceFailed(piece);
        }
      }
    }
    
    // Check connection failures
    for (const conn of this.connections) {
      if (!conn.failed && conn.checkFailure()) {
        failures.connections.push(conn);
        
        if (this.onConnectionFailed) {
          this.onConnectionFailed(conn);
        }
      }
    }
    
    return failures;
  }

  /**
   * Update positions based on forces (for dynamic simulation)
   */
  updatePositions(dt) {
    for (const piece of this.pieces.values()) {
      if (piece.isFixed || piece.failed) continue;
      
      // Simple Euler integration
      const acceleration = piece.netForce.clone().divideScalar(piece.mass);
      piece.velocity.add(acceleration.multiplyScalar(dt));
      piece.velocity.multiplyScalar(this.damping);
      
      const displacement = piece.velocity.clone().multiplyScalar(dt);
      piece.displacement.add(displacement);
      
      // Clamp to ground
      if (piece.position.y + piece.displacement.y < this.groundLevel) {
        piece.displacement.y = this.groundLevel - piece.position.y;
        piece.velocity.y = 0;
      }
    }
  }

  /**
   * Get pieces under high stress
   */
  getOverstressedPieces(threshold = 0.8) {
    const overstressed = [];
    
    for (const piece of this.pieces.values()) {
      const sf = piece.getSafetyFactor();
      if (sf < 1 / threshold) { // Safety factor below 1.25
        overstressed.push({
          piece,
          safetyFactor: sf,
          failureType: this.getPrimaryStressType(piece)
        });
      }
    }
    
    return overstressed.sort((a, b) => a.safetyFactor - b.safetyFactor);
  }

  /**
   * Get primary stress type for a piece
   */
  getPrimaryStressType(piece) {
    const { tension, compression, shear } = piece.stress;
    if (tension >= compression && tension >= shear) return 'tension';
    if (compression >= tension && compression >= shear) return 'compression';
    return 'shear';
  }

  /**
   * Get total structure weight
   */
  getTotalWeight() {
    let total = 0;
    for (const piece of this.pieces.values()) {
      total += piece.mass;
    }
    return total;
  }

  /**
   * Get structure center of mass
   */
  getCenterOfMass() {
    const com = new THREE.Vector3();
    let totalMass = 0;
    
    for (const piece of this.pieces.values()) {
      com.addScaledVector(piece.centerOfMass, piece.mass);
      totalMass += piece.mass;
    }
    
    if (totalMass > 0) {
      com.divideScalar(totalMass);
    }
    
    return com;
  }

  /**
   * Get simulation statistics
   */
  getStats() {
    let minSF = Infinity;
    let maxStrain = 0;
    let failedPieces = 0;
    let failedConnections = 0;
    
    for (const piece of this.pieces.values()) {
      minSF = Math.min(minSF, piece.getSafetyFactor());
      maxStrain = Math.max(maxStrain, piece.strain);
      if (piece.failed) failedPieces++;
    }
    
    for (const conn of this.connections) {
      if (conn.failed) failedConnections++;
    }
    
    return {
      pieceCount: this.pieces.size,
      connectionCount: this.connections.length,
      totalWeight: this.getTotalWeight(),
      minSafetyFactor: minSF === Infinity ? 0 : minSF,
      maxStrain: maxStrain,
      failedPieces,
      failedConnections,
      isStable: failedPieces === 0 && failedConnections === 0 && minSF > 1
    };
  }

  /**
   * Clear simulation
   */
  clear() {
    this.pieces.clear();
    this.connections = [];
  }
}

/**
 * Stress visualization helper
 */
export class StressVisualizer {
  constructor(options = {}) {
    this.lowStressColor = options.lowStressColor ?? new THREE.Color(0x00ff00);
    this.midStressColor = options.midStressColor ?? new THREE.Color(0xffff00);
    this.highStressColor = options.highStressColor ?? new THREE.Color(0xff0000);
  }

  /**
   * Get color for stress level
   */
  getStressColor(safetyFactor) {
    const color = new THREE.Color();
    
    if (safetyFactor >= 3) {
      color.copy(this.lowStressColor);
    } else if (safetyFactor >= 1.5) {
      const t = (safetyFactor - 1.5) / 1.5;
      color.copy(this.midStressColor).lerp(this.lowStressColor, t);
    } else if (safetyFactor >= 1) {
      const t = (safetyFactor - 1) / 0.5;
      color.copy(this.highStressColor).lerp(this.midStressColor, t);
    } else {
      color.copy(this.highStressColor);
    }
    
    return color;
  }

  /**
   * Apply stress visualization to pieces
   */
  visualize(physicsEngine, enabled = true) {
    for (const piece of physicsEngine.pieces.values()) {
      const mesh = piece.piece.mesh || piece.piece;
      if (!mesh.material) continue;
      
      if (!enabled) {
        if (mesh._originalColor) {
          mesh.material.color.copy(mesh._originalColor);
        }
        continue;
      }
      
      if (!mesh._originalColor) {
        mesh._originalColor = mesh.material.color.clone();
      }
      
      const sf = piece.getSafetyFactor();
      const color = this.getStressColor(sf);
      mesh.material.color.copy(color);
    }
  }
}

export default PhysicsEngineLite;