'use strict';

// Remember to install dependencies:
// npm install express multer csv-parser @google-cloud/vertexai json2csv dotenv

import express from "express";
import multer from "multer";
import csv from "csv-parser";
import { Readable } from "stream";
import { VertexAI } from "@google-cloud/vertexai";
import { Parser } from "json2csv";
import "dotenv/config"; // For environment variables (e.g., API keys)

// --- CONFIGURATION ---
const app = express();
const port = 3249;
const upload = multer({ storage: multer.memoryStorage() });
app.use(express.static("public")); // Folder for a simple index.html file

// Batch size - crucial for stability and avoiding API limits
const BATCH_SIZE = 15; 
const MAX_RETRIES = 3;

// --- Vertex AI (Google Cloud) Configuration ---
// Remember to set GCLOUD_PROJECT_ID and GCLOUD_LOCATION environment variables
// and to authenticate (e.g., via 'gcloud auth application-default login')
const vertexAI = new VertexAI({
  project: process.env.GCLOUD_PROJECT_ID,
  location: process.env.GCLOUD_LOCATION,
});

// We use a modern Gemini model that handles JSON well
const generativeModel = vertexAI.getGenerativeModel({
  model: "gemini-2.5-flash-lite", // You can change to gemini-2.5-pro for higher quality
  generationConfig: {
    // We force a JSON response
    responseMimeType: "application/json", 
  },
});

/**
 * Generates a system prompt for the AI to process a batch of products.
 */
const getGpsrBatchPrompt = (productBatch) => {
  // Create a list of products to process
  const productList = productBatch
    .map((row, index) => `${index + 1}. {"name": "${row.name}", "category": "${row.category}"}`)
    .join("\n");
  
  // Dynamically generate the date for the identifier
  const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");

  return `You are an expert in GPSR compliance for e-commerce. Your task is to generate data for a list of products.

  CRITICAL RULES:
  1.  **Output Format**: Your response MUST be a perfectly formatted, single JSON object, which is an array of objects.
  2.  **ID Matching**: Each object in the array must have an "id" key, corresponding to the number from the input list.
  3.  **Data Generation**: For each product, generate:
      * **"warnings"**: (string) A short, 1-2 sentence safety warning in English, based on the name and category (e.g., "Electronics" -> "Do not immerse in water.", "Toys" -> "For children over 3 years. Choking hazard.").
      * **"identifier"**: (string) A suggested unique product identifier. Use the format "GPSR-BATCH-${today}".
      * **"responsible_person"**: (string) A placeholder for the responsible person. Always insert "Your Company Ltd., 1 Example St, London, W1 1AA, compliance@yourcompany.com".
  4.  **No Explanations**: The response must contain ONLY the JSON code.
  
  EXAMPLE INPUT:
  1. {"name": "FPV Drone with 4K Camera", "category": "Electronics"}
  2. {"name": "Plush Bear 30cm", "category": "Toys"}
  
  EXAMPLE YOUR RESPONSE:
  [
    {"id": 1, "warnings": "Keep away from high-voltage lines. Use under adult supervision.", "identifier": "GPSR-BATCH-${today}", "responsible_person": "Your Company Ltd., 1 Example St, London, W1 1AA, compliance@yourcompany.com"},
    {"id": 2, "warnings": "Not suitable for children under 3 years. Choking hazard from small parts.", "identifier": "GPSR-BATCH-${today}", "responsible_person": "Your Company Ltd., 1 Example St, London, W1 1AA, compliance@yourcompany.com"}
  ]
  
  Now process the following list:
  ${productList}
  `;
};

/**
 * Processes an entire batch using a single AI query.
 */
async function processBatchWithAI(batch) {
  let lastError = null;

  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
    try {
      const prompt = getGpsrBatchPrompt(batch);
      const result = await generativeModel.generateContent(prompt);
      const responseText = result.response.candidates[0].content.parts[0].text.trim();
      
      // Parse the JSON response
      const aiDataArray = JSON.parse(responseText);

      // Validation: did the AI return the correct number of results?
      if (Array.isArray(aiDataArray) && aiDataArray.length === batch.length) {
        
        // Create a map for easy data joining
        const resultMap = new Map(aiDataArray.map(item => [item.id, item]));

        const processedBatch = batch.map((row, index) => {
          const aiData = resultMap.get(index + 1); // IDs are 1-based
          if (aiData) {
            return { 
              ...row, 
              warnings: aiData.warnings, 
              identifier: aiData.identifier,
              responsible_person: aiData.responsible_person
            };
          }
          return null; // ID mismatch error
        });

        // If all rows in the batch were parsed correctly
        if (processedBatch.every((item) => item !== null)) {
          return processedBatch; // Success
        }
      }
      lastError = new Error(
        "Invalid JSON format. Received " + aiDataArray.length + " objects instead of " + batch.length + "."
      );
      console.warn(
        "\nBatch validation error. Attempt " + attempt + "/" + MAX_RETRIES + "..."
      );
    } catch (error) {
      lastError = error;
      console.warn(
        "\nAPI error during batch processing (Attempt " + attempt + "/" + MAX_RETRIES + "): " + error.message
      );
      
      // Simple exponential backoff for 429 (rate limit) errors
      if (error.code === 429 || error.message.includes("429")) {
        const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;
        await new Promise((resolve) => setTimeout(resolve, delay));
      }
    }
  }

  console.error(
    `\nFailed to process batch after ${MAX_RETRIES} attempts. Error: ${lastError.message}`
  );
  // Return original data with errors on failure
  return batch.map((row) => ({ 
    ...row, 
    warnings: "PROCESSING ERROR", 
    identifier: "ERROR",
    responsible_person: "ERROR"
  }));
}

// --- MAIN FILE PROCESSING ENDPOINT ---
app.post("/upload", upload.single("csvfile"), (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: "No file uploaded." });
  }

  const allRows = [];
  Readable.from(req.file.buffer)
    .pipe(
      csv({
        separator: ";",
        // Assumes file has headers 'sku', 'name', 'category'
      })
    )
    .on("data", (data) => {
      // Simple row validation
      if (data.sku && data.name && data.category) {
        allRows.push(data);
      }
    })
    .on("end", async () => {
      try {
        console.log(
          `Parsing finished. Found ${allRows.length} valid rows.Starting batch processing (size ${BATCH_SIZE})...`
        );

        const allProcessedResults = [];

        for (let i = 0; i < allRows.length; i += BATCH_SIZE) {
          const batch = allRows.slice(i, i + BATCH_SIZE);
          const processedBatch = await processBatchWithAI(batch);
          allProcessedResults.push(...processedBatch);

          // Log progress in the console
          const progress = Math.min(
            100,
            ((i + BATCH_SIZE) / allRows.length) * 100
          );
          process.stdout.write(`Progress: ${progress.toFixed(2)}% (processed ${Math.min(i + BATCH_SIZE, allRows.length)}/${allRows.length})\r`);
        }

        console.log(
          "\n\nFinished processing all batches. Generating CSV file."
        );

        // Define the output columns
        const fields = ["sku", "name", "category", "warnings", "identifier", "responsible_person"];
        
        const json2csvParser = new Parser({
          fields: fields,
          delimiter: ";",
        });
        const csvOutput = json2csvParser.parse(allProcessedResults);

        res.header("Content-Type", "text/csv; charset=utf-8");
        res.header(
          "Content-Disposition",
          'attachment; filename="gpsr_results.csv"'
        );
        // Add BOM  for correct opening in Excel
        res.status(200).send("\uFEFF" + csvOutput);

      } catch (error) {
        console.error("Critical processing error:", error);
        res
          .status(500)
          .json({ error: "A critical server-side error occurred." });
      }
    });
});

app.listen(port, () => {
  console.log(`Server started. Open http://localhost:${port} in your browser.`);
  console.log("Make sure you have an 'index.html' file in the 'public' folder with a file upload form.");
});

  
  
  
  


  

    
Upload CSV for GPSR Processing
    

      CSV File (sku;name;category):

      
      

      Process and Download