import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';

const INFERENCE_API_URL = process.env.INFERENCE_API_URL || 'http://localhost:8001';
const INFERENCE_API_TIMEOUT = parseInt(process.env.INFERENCE_API_TIMEOUT || '30000', 10);

const CandleSchema = z.object({
  time: z.number(),
  open: z.number(),
  high: z.number(),
  low: z.number(),
  close: z.number(),
  volume: z.number().optional(),
});

const PredictRequestSchema = z.object({
  pair: z.string().min(1),
  timeframe: z.string().min(1),
  candles: z.array(CandleSchema),
});

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();

    const result = PredictRequestSchema.safeParse(body);
    if (!result.success) {
      return NextResponse.json(
        { error: 'Invalid request', details: result.error.flatten() },
        { status: 400 }
      );
    }

    const validatedBody = result.data;

    // Forward request to Python inference service
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), INFERENCE_API_TIMEOUT);

    try {
      const response = await fetch(`${INFERENCE_API_URL}/predict`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-API-Key': process.env.API_KEY || '',
        },
        body: JSON.stringify(validatedBody),
        signal: controller.signal,
      });

      clearTimeout(timeoutId);

      // Forward the response from the inference service
      const data = await response.json();

      if (!response.ok) {
        return NextResponse.json(
          { error: data.detail || 'Prediction failed' },
          { status: response.status }
        );
      }

      return NextResponse.json(data);
    } catch (fetchError: any) {
      clearTimeout(timeoutId);

      if (fetchError.name === 'AbortError') {
        return NextResponse.json(
          { error: 'Prediction request timed out' },
          { status: 504 }
        );
      }

      throw fetchError;
    }
  } catch (error: any) {
    console.error('Predict proxy error:', error);

    // Check if it's a connection error
    if (error.cause?.code === 'ECONNREFUSED' || error.message?.includes('fetch failed')) {
      return NextResponse.json(
        { error: 'Inference service unavailable' },
        { status: 503 }
      );
    }

    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}
