File Upload

export async function fileUploadAgent(input: {
  conversationState: ConversationState;
  files: File[];
  userId: string;
}) {
  const rawFiles = [];

  // Step 1: Parse files
  for (const file of files) {
    const buffer = Buffer.from(await file.arrayBuffer());
    const parsed = await parseFile(buffer, file.name, file.type);

    rawFiles.push({
      buffer,
      filename: file.name,
      mimeType: file.type,
      parsedText: parsed.text,
      metadata: parsed.metadata,
      size: buffer.length,
    });
  }

  // Step 2: Upload to S3
  const uploadedFiles = await uploadFilesToStorage(
    userId,
    conversationStateId,
    rawFiles
  );

  // Step 3: Generate AI descriptions
  const uploadedDatasetsWithDescriptions = await Promise.all(
    uploadedFiles.map(async (file) => {
      const rawFile = rawFiles.find((rf) => rf.filename === file.filename);
      const description = await generateFileDescription(
        file.filename,
        file.mimeType,
        rawFile?.parsedText || ""
      );
      return {
        id: file.id,
        filename: file.filename,
        description,
        path: file.path,
        size: rawFile?.size || 0,
      };
    })
  );

  // Step 4: Update conversation state
  conversationState.values.uploadedDatasets = uploadedDatasetsWithDescriptions;
  await updateConversationState(conversationState.id, conversationState.values);

  return { uploadedDatasets: uploadedDatasetsWithDescriptions, errors: [] };
}

async function generateFileDescription(
  filename: string,
  mimeType: string,
  parsedText: string
): Promise<string> {
  const contentPreview = parsedText.slice(0, 1000);

  const prompt = `Analyze this uploaded file and provide a brief 1-sentence description.

Filename: ${filename}
Type: ${mimeType}
Content preview:
${contentPreview}

Provide a concise description (max 100 characters) that would help identify this dataset for analysis tasks. Focus on:
- What type of data it contains (e.g., gene expression, clinical data, etc.)
- Key characteristics if obvious (e.g., number of samples, time period)

Examples:
- "RNA-seq data from mouse liver with 12,000 genes across 24 samples"
- "Clinical trial results comparing drug A vs placebo, n=500 patients"
- "Longitudinal aging biomarkers measured over 2 years"

Description:`;

  const llmProvider = new LLM({
    name: process.env.PLANNING_LLM_PROVIDER || "google",
    apiKey: process.env[`${PLANNING_LLM_PROVIDER.toUpperCase()}_API_KEY`],
  });

  const response = await llmProvider.createChatCompletion({
    model: process.env.PLANNING_LLM_MODEL || "gemini-2.5-flash",
    messages: [{ role: "user", content: prompt }],
    maxTokens: 100,
  });

  return response.content.trim();
}

export const FILE_TYPES = [
  {
    name: "Excel",
    extensions: [".xlsx", ".xls"],
    mimeTypes: [
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
      "application/vnd.ms-excel",
    ],
    parser: parseExcel,
  },
  {
    name: "CSV",
    extensions: [".csv"],
    mimeTypes: ["text/csv"],
    parser: parseCSV,
  },
  {
    name: "Markdown",
    extensions: [".md"],
    mimeTypes: ["text/markdown"],
    parser: parseMarkdown,
  },
  {
    name: "JSON",
    extensions: [".json"],
    mimeTypes: ["application/json"],
    parser: parseJSON,
  },
  {
    name: "Text",
    extensions: [".txt"],
    mimeTypes: ["text/plain"],
    parser: parseText,
  },
  {
    name: "PDF",
    extensions: [".pdf"],
    mimeTypes: ["application/pdf"],
    parser: parsePDF,
  },
  {
    name: "Image",
    extensions: [".png", ".jpg", ".jpeg", ".webp", ".gif"],
    mimeTypes: ["image/png", "image/jpeg", "image/webp", "image/gif"],
    parser: parseImage,
  },
];

# Storage Provider
STORAGE_PROVIDER=s3

# AWS Configuration
AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_REGION=us-east-1
S3_BUCKET=your-bucket-name

# For S3-compatible services (DigitalOcean Spaces, MinIO, etc.)
S3_ENDPOINT=https://nyc3.digitaloceanspaces.com

# File Size Limits
MAX_FILE_SIZE_MB=2048  # 2GB default

// Extract files from parsed body
let files: File[] = [];
if (parsedBody.files) {
  if (Array.isArray(parsedBody.files)) {
    files = parsedBody.files.filter((f: any) => f instanceof File);
  } else if (parsedBody.files instanceof File) {
    files = [parsedBody.files];
  }
}

// Process files before planning
if (files.length > 0) {
  const { fileUploadAgent } = await import("../agents/fileUpload");

  const fileResult = await fileUploadAgent({
    conversationState,
    files,
    userId: state.values.userId,
  });

  // Files are now available in conversationState.values.uploadedDatasets
}