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 },

  // Calf area (mock data)
  { id: "calf-1", x: 40, y: 75, zone: "legs", label: "Left Calf", baseNoise: 200, warningThreshold: 1800, alarmThreshold: 2200, warningDelayMs: 150000 },
  { id: "calf-2", x: 60, y: 75, zone: "legs", label: "Right Calf", baseNoise: 220, warningThreshold: 1800, alarmThreshold: 2200, warningDelayMs: 150000 },

  // Feet (mock data)
  { id: "feet-1", x: 45, y: 85, zone: "feet", label: "Left Foot", baseNoise: 150, warningThreshold: 1500, alarmThreshold: 1800, warningDelayMs: 180000 },
  { id: "feet-2", x: 55, y: 85, zone: "feet", label: "Right Foot", baseNoise: 160, warningThreshold: 1500, alarmThreshold: 1800, warningDelayMs: 180000 },
];

// 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]) {
      sensorData[sensor.id] = {
        id: sensor.id,
        x: sensor.x,
        y: sensor.y,
        label: sensor.label,
        zone: sensor.zone,
        value: 1000 + Math.random() * 500, // Start with baseline analog value (1000-1500)
        pin: sensor.pin,
        timestamp: new Date().toISOString(),
        source: sensor.pin ? 'hardware' : 'mock',
        data: generateTimeSeriesData(),
        status: 'normal',
        warningThreshold: sensor.warningThreshold,
        alarmThreshold: sensor.alarmThreshold,
        warningDelayMs: sensor.warningDelayMs
      };
    }
  });
}

// Generate time series data for a sensor
function generateTimeSeriesData(hours = 1) {
  const data = [];
  const now = new Date();

  for (let i = hours * 60; i >= 0; i -= 5) {
    const time = new Date(now.getTime() - i * 60 * 1000);
    data.push({
      time: time.toLocaleTimeString("en-US", { hour12: false }),
      timestamp: time.getTime(),
      value: Math.floor(Math.random() * 4096 + Math.sin(i / 60) * 500 + 2000), // 0-4095 range
    });
  }
  return data;
}

// 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, using mock data:', error);
    isHardwareConnected = false;
  }
}

// Convert digital pin state to analog value with noise
function digitalToAnalogValue(pinState: number, baseNoise: number): number {
  // Base value from digital state
  const baseValue = pinState === 1 ? 3000 : 1000; // High when pin is HIGH, low when LOW
  
  // Add realistic noise and variation
  const timeNoise = Math.sin(Date.now() / 10000) * 200; // Slow oscillation
  const randomNoise = (Math.random() - 0.5) * baseNoise;
  const sensorDrift = (Math.random() - 0.5) * 50; // Small drift
  
  const value = baseValue + timeNoise + randomNoise + sensorDrift;
  
  // Clamp between 0 and 4095
  return Math.max(0, Math.min(4095, Math.floor(value)));
}

// Update sensor data from pin change
async function updateSensorFromPin(pin: number, state: number) {
  const mapping = PIN_SENSOR_MAP[pin];
  if (!mapping) return;

  const value = digitalToAnalogValue(state, mapping.baseNoise);
  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: state
  };
  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: state,
      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
    };
  }
}

// Update mock sensor data with variation
function updateMockSensorData() {
  SENSOR_CONFIG.forEach(sensor => {
    if (!sensor.pin && sensorData[sensor.id]) {
      // This is a mock sensor, update with variation
      const currentSensor = sensorData[sensor.id];
      const variation = (Math.random() - 0.5) * 200; // Larger variation for analog values
      const newValue = Math.max(0, Math.min(4095, currentSensor.value + variation));
      const timestamp = Date.now();
      
      // Determine status based on thresholds
      let status = 'normal';
      let warningStartTime = currentSensor.warningStartTime;
      
      if (newValue >= sensor.alarmThreshold) {
        status = 'alarm';
        warningStartTime = undefined; // Clear warning timer for immediate alarm
      } else if (newValue >= sensor.warningThreshold) {
        status = 'warning';
        if (!warningStartTime) {
          warningStartTime = timestamp; // Start warning timer
        } else if (timestamp - warningStartTime >= sensor.warningDelayMs) {
          status = 'alarm'; // Escalate to alarm after delay
        }
      } else {
        warningStartTime = undefined; // Clear warning timer
      }
      
      sensorData[sensor.id] = {
        ...currentSensor,
        value: newValue,
        timestamp: new Date().toISOString(),
        data: [
          ...currentSensor.data.slice(-287), // Keep last ~24 hours
          {
            time: new Date().toLocaleTimeString("en-US", { hour12: false }),
            timestamp: Date.now(),
            value: newValue,
          }
        ],
        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();
    }

    // Update mock sensor data
    updateMockSensorData();

    // 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' : 'Using mock data'
      });
    }
    
    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 });
  }
}