import { NextRequest, NextResponse } from "next/server";
import { logger } from "@/lib/logger";
import OpenAI from "openai";
import { createClient } from "@/lib/supabase/server";
import { checkRateLimit, getClientIP, createRateLimitResponse } from "@/lib/rate-limit";
import { sanitizeInput, stripContactInfo } from "@/lib/sanitize";
import { withCSRFProtection } from "@/lib/csrf";
import { 
  AI_RATE_LIMIT, 
  RATE_LIMIT_WINDOW_MS as AI_WINDOW_MS,
  MAX_LENGTH_TRADE 
} from "@/lib/constants";

if (!process.env.OPENAI_API_KEY) {
  throw new Error("OPENAI_API_KEY environment variable is not set");
}

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Rate limit: 10 requests per 15 minutes per user

const handler = async (request: NextRequest) => {
  try {
    const clientIP = getClientIP(request);
    const rateLimit = await checkRateLimit(`ai-job:${clientIP}`, AI_RATE_LIMIT, AI_WINDOW_MS);

    if (!rateLimit.allowed) {
      const retryAfter = Math.ceil((rateLimit.resetTime - Date.now()) / 1000);
      return createRateLimitResponse(clientIP, retryAfter);
    }

    const supabase = await createClient();
    const { data: { user }, error: authError } = await supabase.auth.getUser();
    if (authError || !user) {
      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
    }

    const { trade } = await request.json();

    if (!trade) {
      return NextResponse.json({ error: "Missing trade" }, { status: 400 });
    }

    const sanitizedTrade = sanitizeInput(trade, { maxLength: MAX_LENGTH_TRADE });

    const completion = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        {
          role: "system",
          content: "You are an Australian construction industry expert. Always respond with valid JSON only.",
        },
        {
          role: "user",
          content: `Generate a job posting for a ${sanitizedTrade} in the Australian construction industry.

Return JSON with:
1. title: A concise job title (e.g. "Experienced Steel Fixer Needed")
2. description: A 3-4 sentence job description mentioning key duties, site expectations, and any specific requirements. Use Australian English. Mention PPE, early starts if relevant.
3. certifications: Array of required certifications (e.g. "White Card", "Working at Heights", "Trade Certificate", "Scaffolding Licence"). Always include "White Card".
4. rateMin: Minimum hourly rate in AUD (realistic 2026 Australian market rate)
5. rateMax: Maximum hourly rate in AUD
6. rateType: "hourly" or "daily"

Return ONLY valid JSON:
{
  "title": "string",
  "description": "string",
  "certifications": ["string"],
  "rateMin": number,
  "rateMax": number,
  "rateType": "hourly"
}`,
        },
      ],
      temperature: 0.7,
      response_format: { type: "json_object" },
    });

    const content = completion.choices[0]?.message?.content;
    if (!content) {
      throw new Error("No response from AI");
    }

    const generated = JSON.parse(content);

    // Validate and sanitize rate values
    const MIN_HOURLY_RATE = 25; // Australian minimum for construction
    const MAX_HOURLY_RATE = 200; // Upper bound for specialist trades
    const DEFAULT_MIN_RATE = 35;
    const DEFAULT_MAX_RATE = 55;

    let rateMin = typeof generated.rateMin === 'number' ? generated.rateMin : DEFAULT_MIN_RATE;
    let rateMax = typeof generated.rateMax === 'number' ? generated.rateMax : DEFAULT_MAX_RATE;

    // Clamp rates to reasonable bounds
    rateMin = Math.max(MIN_HOURLY_RATE, Math.min(rateMin, MAX_HOURLY_RATE));
    rateMax = Math.max(MIN_HOURLY_RATE, Math.min(rateMax, MAX_HOURLY_RATE));

    // Ensure rateMax >= rateMin
    if (rateMax < rateMin) {
      [rateMin, rateMax] = [rateMax, rateMin]; // Swap if reversed
    }

    // Ensure meaningful range (at least $5/hr difference)
    if (rateMax - rateMin < 5) {
      rateMax = rateMin + 10;
      // Re-clamp if we exceeded max
      if (rateMax > MAX_HOURLY_RATE) {
        rateMax = MAX_HOURLY_RATE;
        rateMin = Math.max(MIN_HOURLY_RATE, rateMax - 10);
      }
    }

    return NextResponse.json({
      title: stripContactInfo(generated.title || ""),
      description: stripContactInfo(generated.description || ""),
      certifications: generated.certifications || ["White Card"],
      rateMin,
      rateMax,
      rateType: generated.rateType || "hourly",
    });
  } catch (error) {
    logger.error("AI job generation error:", error);

    if (error instanceof Error) {
      if (error.message.includes("API key")) {
        return NextResponse.json({ error: "AI service configuration error" }, { status: 503 });
      }
      if (error.message.includes("rate limit") || error.message.includes("429")) {
        return NextResponse.json({ error: "AI service is busy. Please try again." }, { status: 429 });
      }
    }

    return NextResponse.json({ error: "Failed to generate job details" }, { status: 500 });
  }
};

export const POST = withCSRFProtection(handler);