import { NextResponse } from "next/server";
import fs from "fs";
import path from "path";

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

    if (!imageUrls || !Array.isArray(imageUrls) || imageUrls.length === 0) {
      return NextResponse.json({ error: "Image URLs array is required" }, { status: 400 });
    }

    console.log(`[Download Images] Downloading ${imageUrls.length} images`);

    // Create uploads directory if it doesn't exist
    const uploadsDir = path.join(process.cwd(), "public", "uploads", "products");
    if (!fs.existsSync(uploadsDir)) {
      fs.mkdirSync(uploadsDir, { recursive: true });
    }

    const results: Array<{ url: string; success: boolean; downloadedUrl?: string; error?: string }> = [];

    // Download images in parallel (limit to 5 at a time to avoid overwhelming)
    const batchSize = 5;
    for (let i = 0; i < imageUrls.length; i += batchSize) {
      const batch = imageUrls.slice(i, i + batchSize);
      const batchResults = await Promise.all(
        batch.map(async (imageUrl: string) => {
          try {
            console.log(`[Download Images] Downloading: ${imageUrl}`);

            // Parse URL to get origin for Referer header
            let referer = "";
            try {
              const urlObj = new URL(imageUrl);
              referer = urlObj.origin;
            } catch (e) {
              // Invalid URL, continue without referer
            }

            // Fetch the image with retry logic
            let response;
            let retries = 3;
            while (retries > 0) {
              try {
                response = await fetch(imageUrl, {
                  headers: {
                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
                    "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
                    "Accept-Language": "en-US,en;q=0.9",
                    "Referer": referer,
                    "Origin": referer,
                  },
                  signal: AbortSignal.timeout(30000),
                });

                if (response.ok) break;
                retries--;
                if (retries > 0) {
                  await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second before retry
                }
              } catch (fetchError) {
                retries--;
                if (retries === 0) throw fetchError;
                await new Promise((resolve) => setTimeout(resolve, 1000));
              }
            }

            if (!response || !response.ok) {
              throw new Error(`Failed to fetch: ${response?.status} ${response?.statusText}`);
            }

            // Get image buffer
            const arrayBuffer = await response.arrayBuffer();
            const buffer = Buffer.from(arrayBuffer);

            // Validate it's actually an image
            if (buffer.length < 100) {
              throw new Error("File too small, likely not an image");
            }

            // Determine file extension
            const contentType = response.headers.get("content-type") || "";
            let extension = "jpg";

            if (contentType.includes("png")) extension = "png";
            else if (contentType.includes("gif")) extension = "gif";
            else if (contentType.includes("webp")) extension = "webp";
            else if (contentType.includes("svg")) extension = "svg";
            else {
              const urlMatch = imageUrl.match(/\.(jpg|jpeg|png|gif|webp|svg)(\?|$)/i);
              if (urlMatch) {
                extension = urlMatch[1].toLowerCase();
                if (extension === "jpeg") extension = "jpg";
              }
            }

            // Generate filename
            const timestamp = Date.now();
            const randomStr = Math.random().toString(36).substring(2, 8);
            const index = imageUrls.indexOf(imageUrl);
            const filename = `product-${timestamp}-${index}-${randomStr}.${extension}`;
            const filepath = path.join(uploadsDir, filename);

            // Save image
            fs.writeFileSync(filepath, buffer);

            // Generate public URL
            const publicUrl = `/uploads/products/${filename}`;

            console.log(`[Download Images] Saved: ${publicUrl}`);

            return {
              url: imageUrl,
              success: true,
              downloadedUrl: publicUrl,
            };
          } catch (error) {
            console.error(`[Download Images] Error downloading ${imageUrl}:`, error);
            return {
              url: imageUrl,
              success: false,
              error: error instanceof Error ? error.message : "Unknown error",
            };
          }
        })
      );

      results.push(...batchResults);

      // Small delay between batches to avoid overwhelming the server
      if (i + batchSize < imageUrls.length) {
        await new Promise((resolve) => setTimeout(resolve, 500));
      }
    }

    const successful = results.filter((r) => r.success);
    const failed = results.filter((r) => !r.success);

    return NextResponse.json({
      success: true,
      total: imageUrls.length,
      successful: successful.length,
      failed: failed.length,
      results: results,
      downloadedUrls: successful.map((r) => r.downloadedUrl),
    });
  } catch (error) {
    console.error("[Download Images] Error:", error);
    return NextResponse.json(
      {
        error: "Failed to process request",
        details: error instanceof Error ? error.message : "Unknown error",
      },
      { status: 500 }
    );
  }
}