import { NextRequest, NextResponse } from 'next/server';
import { bedHardwareInstance, PinState, PinChange } from '@/services/BedHardware';
import { SensorDataStorage, SensorDataPoint } from '@/services/SensorDataStorage';
import { SensorConfig } from '@/types/sensor';

// Complete sensor configuration with positions, pin mappings, and thresholds
const SENSOR_CONFIG: SensorConfig[] = [
  // Head area
  { id: "head-1", x: 45, y: 15, zone: "head", label: "Head Left", pin: 2, baseNoise: 200, warningThreshold: 3000, alarmThreshold: 3500, warningDelayMs: 30000 },
  { id: "head-2", x: 55, y: 15, zone: "head", label: "Head Right", pin: 3, baseNoise: 150, warningThreshold: 3000, alarmThreshold: 3500, warningDelayMs: 30000 },

  // Shoulder area
  { id: "shoulder-1", x: 35, y: 25, zone: "shoulders", label: "Left Shoulder", pin: 4, baseNoise: 250, warningThreshold: 2800, alarmThreshold: 3200, warningDelayMs: 45000 },
  { id: "shoulder-2", x: 65, y: 25, zone: "shoulders", label: "Right Shoulder", pin: 5, baseNoise: 220, warningThreshold: 2800, alarmThreshold: 3200, warningDelayMs: 45000 },

  // Upper back
  { id: "back-1", x: 40, y: 35, zone: "back", label: "Upper Back Left", pin: 6, baseNoise: 300, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },
  { id: "back-2", x: 50, y: 35, zone: "back", label: "Upper Back Center", pin: 7, baseNoise: 350, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },
  { id: "back-3", x: 60, y: 35, zone: "back", label: "Upper Back Right", pin: 8, baseNoise: 280, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },

  // Lower back/Hip area
  { id: "hip-1", x: 35, y: 50, zone: "hips", label: "Left Hip", pin: 9, baseNoise: 400, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
  { id: "hip-2", x: 50, y: 50, zone: "hips", label: "Lower Back", pin: 10, baseNoise: 450, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
  { id: "hip-3", x: 65, y: 50, zone: "hips", label: "Right Hip", pin: 11, baseNoise: 380, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
  // Thigh area
  { id: "thigh-1", x: 40, y: 65, zone: "legs", label: "Left Thigh", pin: 12, baseNoise: 320, warningThreshold: 2000, alarmThreshold: 2500, warningDelayMs: 120000 },
  { id: "thigh-2", x: 60, y: 65, zone: "legs", label: "Right Thigh", pin: 13, baseNoise: 300, warningThreshold: 2000, alarmThreshold: 2500, warningDelayMs: 120000 },
];

// Create pin mapping from sensor config
const PIN_SENSOR_MAP: Record<number, typeof SENSOR_CONFIG[0]> = {};
SENSOR_CONFIG.forEach(sensor => {
  if (sensor.pin) {
    PIN_SENSOR_MAP[sensor.pin] = sensor;
  }
});

const sensorDataStorage = SensorDataStorage.getInstance();
const sensorData: Record<string, {
  id: string;
  x: number;
  y: number;
  label: string;
  zone: string;
  value: number; // Changed from pressure to value (0-4095)
  pin?: number;
  digitalState?: number;
  timestamp: string;
  source: 'hardware' | 'mock';
  data: Array<{ time: string; timestamp: number; value: number }>;
  status: string;
  warningStartTime?: number; // Track when warning state started
  warningThreshold: number;
  alarmThreshold: number;
  warningDelayMs: number;
}> = {};
let isHardwareConnected = false;

// Initialize all sensor data
function initializeSensorData() {
  SENSOR_CONFIG.forEach(sensor => {
    if (!sensorData[sensor.id] && sensor.pin) { // Only initialize sensors with pins (real hardware)
      sensorData[sensor.id] = {
        id: sensor.id,
        x: sensor.x,
        y: sensor.y,
        label: sensor.label,
        zone: sensor.zone,
        value: 0, // Start with zero until real data arrives
        pin: sensor.pin,
        timestamp: new Date().toISOString(),
        source: 'hardware',
        data: [], // Start with empty data array
        status: 'normal',
        warningThreshold: sensor.warningThreshold,
        alarmThreshold: sensor.alarmThreshold,
        warningDelayMs: sensor.warningDelayMs
      };
    }
  });
}



// Initialize hardware connection
async function initializeHardware() {
  if (isHardwareConnected) return;

  try {
    bedHardwareInstance.on('connected', () => {
      console.log('BedHardware connected');
      isHardwareConnected = true;
    });

    bedHardwareInstance.on('disconnected', () => {
      console.log('BedHardware disconnected');
      isHardwareConnected = false;
    });

    bedHardwareInstance.on('pinChanged', (change: PinChange) => {
      updateSensorFromPin(change.pin, change.currentState);
    });

    bedHardwareInstance.on('pinInitialized', (pinState: PinState) => {
      updateSensorFromPin(pinState.pin, pinState.state);
    });

    bedHardwareInstance.on('error', (error) => {
      console.error('BedHardware error:', error);
      isHardwareConnected = false;
    });

    await bedHardwareInstance.connect();  } catch (error) {
    console.warn('Failed to connect to hardware, system will wait for real hardware data:', error);
    isHardwareConnected = false;
  }
}

// Update sensor data from pin change
async function updateSensorFromPin(pin: number, value: number) {
  const mapping = PIN_SENSOR_MAP[pin];
  if (!mapping) return;
  const timestamp = Date.now();
  const time = new Date(timestamp).toLocaleTimeString("en-US", { hour12: false });
    // Save to persistent storage
  const dataPoint: SensorDataPoint = {
    sensorId: mapping.id,
    value,
    timestamp,
    time,
    source: 'hardware',
    pin,
    digitalState: value
  };
  await sensorDataStorage.addDataPoint(dataPoint);
  
  if (sensorData[mapping.id]) {
    // Update existing sensor data
    const currentData = sensorData[mapping.id];
    
    // Determine status based on thresholds
    let status = 'normal';
    let warningStartTime = currentData.warningStartTime;
    
    if (value >= mapping.alarmThreshold) {
      status = 'alarm';
      warningStartTime = undefined; // Clear warning timer for immediate alarm
    } else if (value >= mapping.warningThreshold) {
      status = 'warning';
      if (!warningStartTime) {
        warningStartTime = timestamp; // Start warning timer
      } else if (timestamp - warningStartTime >= mapping.warningDelayMs) {
        status = 'alarm'; // Escalate to alarm after delay
      }
    } else {
      warningStartTime = undefined; // Clear warning timer
    }
      sensorData[mapping.id] = {
      ...currentData,
      value,
      digitalState: value,
      timestamp: new Date().toISOString(),
      source: 'hardware',
      data: [
        ...currentData.data.slice(-287), // Keep last ~24 hours (288 points at 5min intervals)
        {
          time,
          timestamp,
          value: value,
        }
      ],
      status,
      warningStartTime
    };
  }
}



export async function GET() {
  try {
    // Initialize sensor data if not already done
    if (Object.keys(sensorData).length === 0) {
      initializeSensorData();
    }    // Initialize hardware if not already done
    if (!isHardwareConnected) {
      await initializeHardware();
    }

    // If hardware is connected, get current pin states
    if (isHardwareConnected) {
      const pinStates = bedHardwareInstance.getAllPinStates();
      for (const pinState of pinStates) {
        await updateSensorFromPin(pinState.pin, pinState.state);
      }
    }

    // Return all sensor data
    return NextResponse.json({
      success: true,
      connected: isHardwareConnected,
      sensors: Object.values(sensorData),
      timestamp: new Date().toISOString()
    });

  } catch (error) {
    console.error('Sensor API error:', error);
    return NextResponse.json({
      success: false,
      error: 'Failed to get sensor data',
      connected: false,
      sensors: [],
      timestamp: new Date().toISOString()
    }, { status: 500 });
  }
}

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    
    if (body.action === 'connect') {
      await initializeHardware();
      return NextResponse.json({
        success: true,
        connected: isHardwareConnected,
        message: isHardwareConnected ? 'Hardware connected' : 'Hardware connection failed'
      });
    }
    
    if (body.action === 'disconnect') {
      if (bedHardwareInstance) {
        await bedHardwareInstance.disconnect();
        isHardwareConnected = false;
      }
      return NextResponse.json({
        success: true,
        connected: false,
        message: 'Hardware disconnected'
      });
    }

    return NextResponse.json({
      success: false,
      error: 'Invalid action'
    }, { status: 400 });

  } catch (error) {
    console.error('Sensor API POST error:', error);
    return NextResponse.json({
      success: false,
      error: 'Failed to process request'
    }, { status: 500 });
  }
}