import { SafetyZone, TelemetryPacket, ControlAction, FeedbackChannel } from './types';

interface CellConfig {
  safetyZones: SafetyZone[];
  hmiEndpoint: string;
  maxCycleTime: number;
}

export class CollaborativeCell {
  private config: CellConfig;
  private feedbackChannel: FeedbackChannel;
  private isOperatorPresent: boolean = false;

  constructor(config: CellConfig) {
    this.config = config;
    this.feedbackChannel = new FeedbackChannel(config.hmiEndpoint);
  }

  /**
   * Evaluates the current cycle against safety, efficiency, and human constraints.
   * Returns a control action that respects operator presence and safety zones.
   */
  public evaluateCycle(telemetry: TelemetryPacket): ControlAction {
    const riskAssessment = this.assessRisk(telemetry);
    
    // Safety is non-negotiable; check zones first
    if (riskAssessment.level === 'CRITICAL') {
      this.feedbackChannel.sendAlert({
        type: 'SAFETY_STOP',
        message: 'Proximity breach detected. Halting motion.',
        actionRequired: 'RESET'
      });
      return { type: 'HALT', reason: 'SAFETY_OVERRIDE', timestamp: Date.now() };
    }

    // If operator is present, adjust for collaboration mode
    if (this.isOperatorPresent) {
      return this.generateCollaborativeAction(telemetry, riskAssessment);
    }

    // Standard efficiency optimization when safe
    return this.generateEfficiencyAction(telemetry);
  }

  private assessRisk(telemetry: TelemetryPacket): { level: 'SAFE' | 'WARNING' | 'CRITICAL', distance: number } {
    // Logic to calculate risk based on proximity sensors and velocity
    const closestZone = this.config.safetyZones
      .filter(zone => zone.proximity <= telemetry.operatorDistance)
      .sort((a, b) => a.proximity - b.proximity)[0];

    if (!closestZone) return { level: 'SAFE', distance: telemetry.operatorDistance };
    
    return {
      level: closestZone.action === 'stop' ? 'CRITICAL' : 'WARNING',
      distance: telemetry.operatorDistance
    };
  }

  private generateCollaborativeAction(telemetry: TelemetryPacket): ControlAction {
    // Reduce speed, provide guidance, or pause for operator input
    this.feedbackChannel.sendGuidance({
      type: 'AR_OVERLAY',
      instruction: 'Align component before proceeding.',
      timeout: 5000
    });
    return { type: 'SLOW_MODE', speedFactor: 0.5, reason: 'OPERATOR_SUPPORT' };
  }
}

Safety Kernel Separation: Safety logic is evaluated before efficiency logic. This ensures that optimization never compromises operator safety.

• Feedback Channel: Decouples the control logic from the HMI/AR implementation, allowing the feedback mechanism to evolve independently.

2. Edge AI for Quality and Stability

Edge AI models must detect quality drift, vibration anomalies, and process instability close to the machine. This reduces latency and ensures data ownership remains within the plant.

Implementation Pattern: Deploy lightweight inference models on edge gateways. These models process high-frequency sensor data locally and only transmit aggregated insights or anomalies to the cloud. This approach supports real-time quality control without bandwidth saturation.

Code Example: Edge Quality Agent

import { ModelInference, AnomalyScore } from './edge-ai';

export class EdgeQualityAgent {
  private model: ModelInference;
  private localBuffer: number[] = [];
  private readonly BUFFER_SIZE = 100;

  constructor(modelPath: string) {
    this.model = ModelInference.load(modelPath);
  }

  /**
   * Processes incoming sensor data and detects anomalies locally.
   * Returns immediate control feedback and queues insights for cloud sync.
   */
  public processSample(sensorData: Float32Array): { action: string, insight?: object } {
    this.localBuffer.push(...sensorData);
    if (this.localBuffer.length > this.BUFFER_SIZE) {
      this.localBuffer = this.localBuffer.slice(-this.BUFFER_SIZE);
    }

    const prediction = this.model.predict(this.localBuffer);
    
    if (prediction.anomalyScore > 0.85) {
      // Immediate action: flag part for inspection
      return { action: 'FLAG_INSPECTION' };
    }

    if (prediction.driftDetected) {
      // Predictive action: schedule maintenance or adjust parameters
      return {
        action: 'ADJUST_PARAMETERS',
        insight: {
          type: 'QUALITY_DRIFT',
          confidence: prediction.confidence,
          recommendedAdjustment: prediction.adjustmentVector
        }
      };
    }

    return { action: 'CONTINUE' };
  }
}

Rationale:

• Local Inference: Ensures millisecond response times for quality decisions.
• Buffer Management: Maintains a rolling window of data for context-aware predictions without excessive memory usage.
• Actionable Output: Returns specific actions (FLAG_INSPECTION, ADJUST_PARAMETERS) rather than raw scores, enabling direct integration with control systems.

3. Live Digital Twins

Digital twins must remain connected to real telemetry. Static simulation documents provide limited value. The twin should reflect the current state of the physical asset and support what-if analysis for operators.

Implementation Pattern: Establish a bi-directional sync between the physical machine and the twin. The twin consumes real-time telemetry and can push configuration updates or simulation results back to the operator interface.

Architecture Decision: Use a message broker (e.g., MQTT or AMQP) with QoS levels to ensure critical state updates are delivered. Implement a twin shadow pattern where the twin maintains the last known state and reconciles with the physical device upon reconnection.

4. Data Sovereignty and Clean IIoT Integration

Industrial IoT must expose clean data to MES, SCADA, and maintenance tools without creating cloud dependencies for every machine.

Implementation Pattern: Deploy an edge data gateway that normalizes machine protocols (OPC UA, Modbus) into a unified schema. The gateway handles data retention policies, filtering, and aggregation. Only anonymized or aggregated data is sent to the cloud for long-term analytics.

Rationale:

• Protocol Normalization: Abstracts machine heterogeneity, providing a consistent API for downstream systems.
• Retention Policies: Ensures compliance with data governance requirements and reduces storage costs.
• Cloud Independence: Critical operations continue even if cloud connectivity is lost.

Pitfall Guide

Implementing human-centric architectures introduces new complexities. The following pitfalls are common in production environments.

1. The Dashboard Trap

Explanation: Teams collect vast amounts of data and present it on dashboards without defining actionable insights. Operators are overwhelmed with information and cannot distinguish signal from noise. Fix: Implement a decision-support layer. Alerts should include context, recommended actions, and confidence levels. Use role-based views to show only relevant data to each operator.

2. Static Digital Twins

Explanation: Twins are built as offline simulations and never updated with live telemetry. They become outdated documentation rather than operational tools. Fix: Enforce bi-directional sync. The twin must update in real-time and support operator interactions that can be simulated and validated before applying to the physical machine.

3. Cloud-First Criticality

Explanation: Safety and quality control logic is hosted in the cloud. Network latency or outages cause production halts or safety risks. Fix: Adopt an edge-first architecture. Critical control loops, safety checks, and quality decisions must run locally. Cloud connectivity should be used for analytics, reporting, and model updates.

4. Ignoring Cognitive Load

Explanation: New interfaces and alerts increase the mental burden on operators, leading to fatigue and errors. Fix: Design for cognitive ergonomics. Use AR guidance, simplified HMIs, and progressive disclosure of information. Validate interfaces with operator feedback loops during development.

5. Unmaintainable AI Pilots

Explanation: AI models are developed by data scientists but cannot be maintained or retrained by plant teams. Models degrade over time as processes change. Fix: Implement MLOps for edge. Provide tools for operators to label data, retrain models, and deploy updates. Version control models and track performance metrics.

6. Security as an Afterthought

Explanation: Cybersecurity is treated as a final audit item rather than a design constraint. Vulnerabilities are discovered late, delaying deployment. Fix: Shift-left security. Integrate security testing into the CI/CD pipeline. Use secure boot, encrypted communications, and regular OTA updates. Treat security as part of the production line.

7. Lack of Operator Override

Explanation: Automation systems do not allow operators to intervene when exceptions occur. This leads to frustration and workarounds that bypass safety. Fix: Design mandatory human-in-the-loop checkpoints. Provide clear override mechanisms with audit trails. Ensure operators can safely pause, adjust, or resume operations.

Production Bundle

Action Checklist

• Audit Operator Pain Points: Identify bottlenecks, safety risks, and cognitive load issues before selecting technology.
• Define Data Residency: Establish clear boundaries for edge vs. cloud data. Specify retention policies and access controls.
• Implement Safety Kernels: Deploy local safety logic with dynamic zone management and immediate feedback channels.
• Instrument Sustainability Metrics: Track energy consumption, scrap rates, and maintenance indicators at the cell level.
• Design Feedback Loops: Create operator interfaces that provide context, guidance, and override capabilities.
• Validate Edge AI: Test quality and anomaly detection models under realistic conditions with operator validation.
• Establish OTA Pipelines: Configure secure update mechanisms for edge controllers, AI models, and firmware.
• Conduct Stress Tests: Simulate network failures, sensor errors, and operator interventions to verify resilience.

Decision Matrix

Use this matrix to select the appropriate approach based on production scenarios.

Scenario	Recommended Approach	Why	Cost Impact
High-speed repetitive task	Traditional automation with edge monitoring	Maximizes throughput; human intervention is minimal.	Low CapEx, Low OpEx
Variable assembly / High mix	Collaborative cells with AR guidance	Supports flexibility; reduces changeover time.	Medium CapEx, High ROI
Latency-sensitive quality check	Edge AI inference	Ensures real-time detection; avoids cloud latency.	Medium CapEx, Reduces scrap
Historical analytics / Reporting	Cloud aggregation	Scalable storage; advanced analytics capabilities.	Low CapEx, Subscription OpEx
Safety-critical operation	Local safety kernel with override	Guarantees response time; maintains operator control.	High CapEx, Risk mitigation
Energy optimization	Dynamic load balancing at edge	Reduces energy costs; adapts to real-time pricing.	Medium CapEx, OpEx savings

Configuration Template

Use this template to configure a collaborative production cell. Adapt parameters to your specific environment.

cell:
  id: "CELL-042"
  type: "collaborative_assembly"
  
safety:
  zones:
    - id: "zone_a"
      proximity_mm: 500
      action: "warn"
      speed_factor: 0.8
    - id: "zone_b"
      proximity_mm: 200
      action: "slow"
      speed_factor: 0.3
    - id: "zone_c"
      proximity_mm: 50
      action: "stop"
      speed_factor: 0.0
  override:
    enabled: true
    audit_trail: true

edge_ai:
  model: "quality_drift_v2.onnx"
  inference_interval_ms: 100
  anomaly_threshold: 0.85
  feedback:
    enabled: true
    channel: "hmi_alerts"

data:
  retention_days: 90
  cloud_sync:
    enabled: true
    interval_seconds: 60
    schema: "unified_telemetry_v1"

operator_interface:
  type: "ar_hmi"
  guidance:
    enabled: true
    timeout_seconds: 10
  feedback:
    channels: ["visual", "audio", "haptic"]

Quick Start Guide

Follow these steps to deploy a human-centric production cell in under 5 minutes.

1. Map the Workflow: Identify the operator's role, safety zones, and critical decision points. Define where human intervention is required.
2. Deploy Edge Agent: Install the edge gateway and configure data collection from machines. Set up the safety kernel and feedback channels.
3. Configure Safety Zones: Define proximity thresholds and actions in the configuration template. Test the safety logic with simulated operator presence.
4. Connect Live Twin: Establish bi-directional sync between the edge agent and the digital twin. Verify real-time state updates.
5. Run Validation: Conduct a stress test with operator intervention. Verify that safety overrides, feedback loops, and edge AI decisions function as expected.

This architecture enables a production system that is resilient, sustainable, and optimized for human collaboration. By treating operators as integral components of the control loop and leveraging edge intelligence, manufacturers can achieve higher efficiency, lower costs, and improved operator satisfaction.