import { generateText, tool } from "ai"
import Papa from "papaparse"
import { z } from "zod"

import {
  buildFilterPredicate,
  coerceValue,
  detectColumnType,
  extractReplacementInstruction,
  isNullishOrEmpty,
  normalizeCsv,
  normalizeRowsToFields,
  parseCsvWithFallback,
  PREFIX_REGEX,
  resolveColumnReference,
  SUFFIX_REGEX,
} from "../../sheet-utils"
import { TableEditorArtifact } from "../artifacts/table-editor"
import {
  getCurrentArtifactData,
  getCurrentArtifactInstance,
  getCurrentUser,
  setCurrentArtifactData,
} from "../context"
import type { ArtifactDataWithMetadata, ArtifactSummary } from "../types"

const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

// Dedicated tool for adding new data to existing tables
export const addDataTool = tool({
  description:
    "Add new rows of data to an existing table. This tool is specifically designed for merging new data with existing datasets.",
  inputSchema: z.object({
    csv: z.string().describe("CSV data containing the new rows to add"),
    mergeStrategy: z
      .enum(["append", "prepend", "insert_at_index"])
      .default("append")
      .describe("Strategy for merging new data with existing data"),
    description: z
      .string()
      .optional()
      .describe("Optional description of the data being added"),
  }),
  execute: async ({ csv, mergeStrategy = "append", description }) => {
    const user = getCurrentUser()

    console.log("➕ ADD DATA TOOL EXECUTION START")
    console.log("📊 Strategy:", mergeStrategy)
    console.log("📄 CSV Length:", csv?.length || 0)
    console.log("📝 Description:", description)
    console.log("👤 User:", user.fullName)

    // Get existing artifact data
    const existingData = getCurrentArtifactData()

    if (!existingData) {
      return {
        text: "No existing table found. Please create a table first before adding data to it.",
        parts: [],
      }
    }

    const previousVersion = existingData.artifactVersion ?? 0

    if (!csv || csv.trim() === "") {
      return {
        text: "No CSV data provided. Please provide the data you want to add to the table.",
        parts: [],
      }
    }

    try {
      // Parse existing data
      const existingParseResult = parseCsvWithFallback(existingData.csvContent)
      const existingFields = existingParseResult.fields
      const existingRows = existingParseResult.rows

      // Parse new data (supporting headerless single-row CSV)
      const newParseResult = parseCsvWithFallback(csv, existingFields)
      const newFields = newParseResult.fields
      const newRows = newParseResult.rows

      console.log(
        "📊 Existing data - Fields:",
        existingFields.length,
        "Rows:",
        existingRows.length
      )
      console.log(
        "📊 New data - Fields:",
        newFields.length,
        "Rows:",
        newRows.length
      )

      if (newRows.length === 0) {
        return {
          text: "No valid rows found in the provided data. Please check your CSV format.",
          parts: [],
        }
      }

      // Normalize new rows to match existing column structure
      const normalizedNewRows = normalizeRowsToFields(
        newRows,
        newFields,
        existingFields
      )

      console.log("📊 Normalized new rows:", normalizedNewRows.length)

      // Merge data based on strategy
      let mergedRows: Record<string, string>[] = []

      switch (mergeStrategy) {
        case "prepend":
          mergedRows = [...normalizedNewRows, ...existingRows]
          break
        case "insert_at_index":
          // For now, default to append behavior
          mergedRows = [...existingRows, ...normalizedNewRows]
          break
        default:
          mergedRows = [...existingRows, ...normalizedNewRows]
          break
      }

      console.log("📊 Final merged rows:", mergedRows.length)

      // Generate new CSV
      const enhancedCsv = Papa.unparse({
        fields: existingFields,
        data: mergedRows,
      })

      // Create new version
      const newVersion = {
        version: existingData.versions.length + 1,
        label: `Added ${normalizedNewRows.length} new rows`,
        csvContent: enhancedCsv,
        createdAt: Date.now(),
        description:
          description ||
          `Added ${normalizedNewRows.length} new rows using ${mergeStrategy} strategy`,
        operations: [`add-data-${Date.now()}`],
      }

      const updatedVersions = [...existingData.versions, newVersion]

      // Update summary
      const updatedSummary: ArtifactSummary = {
        ...existingData.summary,
        rowCount: mergedRows.length,
        columnCount: existingFields.length,
        sampleRows: existingData.summary?.sampleRows ?? [],
        columnProfiles: existingData.summary?.columnProfiles ?? [],
      }

      // Create new artifact instance with proper streaming
      const table = TableEditorArtifact.stream({
        title: existingData.title,
        stage: "loading",
        csvContent: existingData.csvContent,
        progress: 0.1,
        operations: existingData.operations,
        versions: existingData.versions,
        summary: existingData.summary,
        currentOperation: {
          id: `add-data-${Date.now()}`,
          label: `Adding ${normalizedNewRows.length} new rows`,
          progress: 0.1,
        },
      })

      const streamInternal = table as unknown as {
        instance?: { version: number; updatedAt: number }
      }

      if (previousVersion > 0 && streamInternal.instance) {
        streamInternal.instance.version = previousVersion
      }

      // Stream updates to show progress
      await table.update({
        stage: "applying_changes",
        progress: 0.3,
        currentOperation: {
          id: `add-data-${Date.now()}`,
          label: `Merging ${normalizedNewRows.length} new rows`,
          progress: 0.3,
        },
      })

      await table.update({
        stage: "applying_changes",
        progress: 0.7,
        csvContent: enhancedCsv,
        currentOperation: {
          id: `add-data-${Date.now()}`,
          label: "Finalizing merge",
          progress: 0.7,
        },
      })

      // Complete the update
      await table.complete({
        title: existingData.title,
        stage: "complete",
        progress: 1,
        csvContent: enhancedCsv,
        summary: updatedSummary,
        operations: existingData.operations,
        versions: updatedVersions,
        currentOperation: undefined,
      })

      const finalVersion = streamInternal.instance?.version ?? previousVersion

      // Save updated data to context for future operations
      setCurrentArtifactData({
        artifactId: table.id,
        artifactVersion: finalVersion,
        csvContent: enhancedCsv,
        summary: updatedSummary,
        operations: existingData.operations,
        versions: updatedVersions,
        title: existingData.title,
        stage: "complete",
        progress: 1,
      })

      console.log("✅ Add data completed successfully")
      console.log("📊 Final CSV length:", enhancedCsv.length)
      console.log("➕ ADD DATA TOOL EXECUTION END")

      return {
        text: `Successfully added ${normalizedNewRows.length} new rows to the table. The table now has ${mergedRows.length} total rows (was ${existingRows.length}).`,
        parts: [
          {
            type: `data-artifact-${TableEditorArtifact.id}`,
            data: {
              id: table.id,
              version: finalVersion,
              status: "complete" as const,
              progress: 1,
              payload: {
                title: existingData.title,
                stage: "complete",
                progress: 1,
                csvContent: enhancedCsv,
                summary: updatedSummary,
                operations: existingData.operations,
                versions: updatedVersions,
                currentOperation: undefined,
              },
              createdAt: Date.now(),
            },
          },
        ],
      }
    } catch (error) {
      console.error("❌ Add data error:", error)
      return {
        text: `Error adding data to table: ${error instanceof Error ? error.message : String(error)}`,
        parts: [],
      }
    }
  },
})

export const tableEditorTool = tool({
  description:
    "Create and modify interactive table editors with AI-assisted transformations. Can create new tables or apply changes to existing ones. Provide CSV data, structured rows, or transformation instructions.",
  inputSchema: z.object({
    title: z.string().optional(),
    csv: z.string().optional(),
    rows: z
      .array(
        z.record(
          z.string(),
          z.union([z.string(), z.number(), z.boolean(), z.null()])
        )
      )
      .optional(),
    instructions: z
      .array(z.string())
      .describe("High-level transformation goals or specific operations")
      .default([]),
    operation: z
      .enum([
        "create",
        "add_column",
        "filter_rows",
        "sort_data",
        "calculate",
        "clean_data",
        "merge_data",
        "analyze",
        "transform",
        "edit_column",
      ])
      .describe("Type of operation to perform")
      .default("create"),
    targetColumns: z.array(z.string()).optional(),
    filterCriteria: z.string().optional(),
    sortBy: z.string().optional(),
    sortOrder: z.enum(["asc", "desc"]).optional(),
    editColumn: z
      .string()
      .optional()
      .describe(
        "Column letter or name to edit (e.g., 'A', 'Name', 'Column A')"
      ),
    editInstruction: z
      .string()
      .optional()
      .describe("Specific instruction for how to edit the column data"),
    mergeStrategy: z
      .enum(["append", "prepend", "insert_at_index"])
      .optional()
      .describe("Strategy for merging new data with existing data"),
  }),
  execute: async ({
    title,
    csv,
    rows = [],
    instructions,
    operation = "create",
    targetColumns: _targetColumns = [],
    filterCriteria: _filterCriteria,
    sortBy: _sortBy,
    sortOrder: _sortOrder = "asc",
    editColumn: _editColumn,
    editInstruction: _editInstruction,
    mergeStrategy = "append",
  }) => {
    const user = getCurrentUser()

    console.log("🔧 TABLE EDITOR TOOL EXECUTION START")
    console.log("📊 Operation:", operation)
    console.log("📝 Edit Column:", _editColumn)
    console.log("📝 Edit Instruction:", _editInstruction)
    console.log("📄 CSV Length:", csv?.length || 0)
    console.log("📋 Instructions:", instructions)
    console.log("🔗 Merge Strategy:", mergeStrategy)
    console.log("👤 User:", user.fullName)

    // Check if we're updating an existing artifact or creating a new one
    // For merge_data operations, we always need to load existing data regardless of CSV input
    const isUpdate = operation !== "create"

    console.log("🔄 Is Update Operation:", isUpdate)

    let csvContent = csv ?? ""
    let existingData: ArtifactDataWithMetadata | null = null
    const existingInstance = getCurrentArtifactInstance()

    console.log(
      "📦 Existing Instance:",
      existingInstance ? `ID: ${existingInstance.id}` : "None"
    )

    // If this is an update operation, we need to get the current artifact data
    if (isUpdate) {
      // Get the current artifact data from context
      existingData = getCurrentArtifactData() || null
      console.log(
        "📦 Retrieved Existing Data:",
        existingData
          ? `CSV Length: ${existingData.csvContent.length}, Versions: ${existingData.versions.length}`
          : "None"
      )
    }

    if (!csvContent && rows.length > 0) {
      csvContent = Papa.unparse(rows.map((row) => ({ ...row })))
    }

    const normalizedCsv = normalizeCsv(csvContent)

    if (!normalizedCsv && rows.length === 0 && operation === "create") {
      return {
        text: "I couldn't detect any tabular data. Please paste CSV rows or provide a rows array so I can build the table editor.",
        parts: [],
      }
    }

    // Determine the starting CSV content
    // For merge operations, always use existing data as base, then merge new CSV
    // For other operations, use existing data if available, otherwise use new CSV
    const startingCsv =
      isUpdate && existingData?.csvContent
        ? existingData.csvContent
        : normalizedCsv

    // Determine the starting versions
    const startingVersions =
      isUpdate && existingData?.versions?.length
        ? existingData.versions
        : [
            {
              version: 1,
              label: "Original upload",
              csvContent: startingCsv,
              createdAt: Date.now(),
            },
          ]

    // Create new artifact instance with proper streaming
    console.log("🆕 CREATING ARTIFACT INSTANCE")
    console.log("📊 Stage:", isUpdate ? "applying_changes" : "loading")
    console.log("📄 Starting CSV length:", startingCsv.length)

    const table = TableEditorArtifact.stream({
      title: title ?? existingData?.title ?? "AI Table Editor",
      stage: isUpdate ? "applying_changes" : "loading",
      csvContent: startingCsv,
      progress: isUpdate ? 0.1 : 0.05,
      operations: existingData?.operations ?? [],
      versions: startingVersions,
      summary: existingData?.summary,
      currentOperation: isUpdate
        ? {
            id: `operation-${Date.now()}`,
            label: "Processing changes",
            progress: 0.1,
          }
        : undefined,
    })

    console.log("🆔 New instance ID:", table.id)

    const streamInternal = table as unknown as {
      instance?: { version: number; updatedAt: number }
    }

    const previousVersion = existingData?.artifactVersion ?? 0
    if (previousVersion > 0 && streamInternal.instance) {
      streamInternal.instance.version = previousVersion
    }

    await delay(400)

    const parseResult = Papa.parse<Record<string, string>>(startingCsv, {
      header: true,
      skipEmptyLines: true,
      dynamicTyping: false,
    })

    const fields = parseResult.meta.fields ?? []
    const dataRows = (parseResult.data ?? []).filter((row) =>
      Object.values(row).some((value) => !isNullishOrEmpty(value))
    )

    const columnProfiles = fields.map((field) => {
      const values = dataRows.map((row) => row[field] ?? "")
      const inferredType = detectColumnType(values)
      const filled =
        values.filter((value) => !isNullishOrEmpty(value)).length /
        (values.length || 1)
      const examples = Array.from(
        new Set(values.filter((value) => !isNullishOrEmpty(value)))
      ).slice(0, 3)

      return {
        name: field,
        inferredType,
        filled,
        examples,
      }
    })

    let workingFields = [...fields]
    let workingRows = dataRows.map((row) => ({ ...row }))

    const summarySample = workingRows.slice(0, 3).map((row) => ({ ...row }))

    const summaryDetails = {
      rowCount: workingRows.length,
      columnCount: workingFields.length,
      sampleRows: summarySample,
      columnProfiles,
    }

    // Stream profiling stage
    await table.update({
      stage: "profiling",
      progress: 0.35,
      summary: summaryDetails,
      currentOperation: {
        id: `operation-${Date.now()}`,
        label: "Analyzing data structure",
        progress: 0.35,
      },
    })

    await delay(400)

    // Generate transformation suggestions based on operation type
    const suggestions: {
      id: string
      label: string
      status: "pending" | "applied" | "skipped" | "applying"
      preview?: string
      description?: string
    }[] = []

    let enhancedCsv = startingCsv
    let appliedOperations = 0
    let operationDescription = ""
    let latestSummary = summaryDetails

    // Handle different operation types
    console.log("🔄 Processing operation:", operation)
    switch (operation) {
      case "add_column":
        if (instructions.length > 0) {
          instructions.forEach((instruction, index) => {
            suggestions.push({
              id: `add-column-${index + 1}`,
              label: `Add column: ${instruction}`,
              status: "applying",
              description: instruction,
            })
          })
        }
        operationDescription = "Adding new calculated columns"
        break

      case "filter_rows":
        if (_filterCriteria) {
          suggestions.push({
            id: "filter-rows",
            label: `Filter rows: ${_filterCriteria}`,
            status: "applying",
            description: _filterCriteria,
          })
        }
        operationDescription = "Filtering data based on criteria"
        break

      case "sort_data":
        if (_sortBy) {
          suggestions.push({
            id: "sort-data",
            label: `Sort by ${_sortBy} (${_sortOrder})`,
            status: "applying",
            description: `Sorting data by ${_sortBy} in ${_sortOrder}ending order`,
          })
        }
        operationDescription = "Sorting data"
        break

      case "calculate": {
        const numericColumns = columnProfiles
          .filter(
            (profile) =>
              profile.inferredType === "number" ||
              profile.inferredType === "currency"
          )
          .map((profile) => profile.name)

        if (numericColumns.length >= 2) {
          suggestions.push({
            id: "calculate-totals",
            label: `Calculate totals for ${numericColumns.join(", ")}`,
            status: "applying",
            description: "Adding calculated columns for numeric data",
          })
        }
        operationDescription = "Performing calculations"
        break
      }

      case "clean_data":
        suggestions.push({
          id: "clean-data",
          label: "Clean and normalize data",
          status: "applying",
          description:
            "Removing empty rows, trimming whitespace, standardizing formats",
        })
        operationDescription = "Cleaning data"
        break

      case "edit_column":
        console.log("✏️ EDIT COLUMN OPERATION")
        console.log("📝 Column:", _editColumn)
        console.log("📝 Instruction:", _editInstruction)

        if (_editColumn && _editInstruction) {
          suggestions.push({
            id: "edit-column",
            label: `Edit column ${_editColumn}: ${_editInstruction}`,
            status: "applying",
            description: `Modifying data in column ${_editColumn}`,
          })
          console.log("✅ Edit column suggestion added")
        }
        operationDescription = "Editing column data"
        break

      case "merge_data":
        console.log("🔗 MERGE DATA OPERATION")
        console.log("📊 Merge Strategy:", mergeStrategy)
        console.log("📄 New CSV Length:", csv?.length || 0)

        if (csv?.trim()) {
          suggestions.push({
            id: "merge-data",
            label: `Merge new data (${mergeStrategy})`,
            status: "applying",
            description: `Adding new rows to existing dataset using ${mergeStrategy} strategy`,
          })
        }
        operationDescription = "Merging new data"
        break

      default: {
        console.log("⚠️ Using default case for operation:", operation)
        console.log("📋 Instructions:", instructions)
        console.log("📄 CSV provided:", !!csv)

        // Check if this looks like a merge request
        const isMergeRequest =
          instructions.some(
            (instruction) =>
              instruction.toLowerCase().includes("add") &&
              (instruction.toLowerCase().includes("data") ||
                instruction.toLowerCase().includes("cities") ||
                instruction.toLowerCase().includes("rows") ||
                instruction.toLowerCase().includes("entries") ||
                instruction.toLowerCase().includes("more"))
          ) ||
          (csv?.trim() && isUpdate)

        if (isMergeRequest && csv?.trim()) {
          console.log(
            "🔄 Detected merge request in default case, switching to merge_data"
          )
          operation = "merge_data"
          suggestions.push({
            id: "merge-data-fallback",
            label: `Merge new data (${mergeStrategy})`,
            status: "applying",
            description: `Adding new rows to existing dataset using ${mergeStrategy} strategy`,
          })
          operationDescription = "Merging new data"
        } else if (instructions.length > 0) {
          instructions.forEach((instruction, index) => {
            suggestions.push({
              id: `instruction-${index + 1}`,
              label: instruction,
              status: "applying",
              description: instruction,
            })
          })
        }
        operationDescription =
          operationDescription || "Applying transformations"
      }
    }

    // Apply transformations based on operation type
    if (operation === "calculate" || operation === "add_column") {
      const numericColumns = columnProfiles
        .filter(
          (profile) =>
            profile.inferredType === "number" ||
            profile.inferredType === "currency"
        )
        .map((profile) => profile.name)

      if (numericColumns.length >= 2) {
        // Generate a meaningful column name based on user instructions and context
        const columnName = await generateColumnName(
          instructions,
          numericColumns,
          operation
        )

        const enhancedRows = workingRows.map((row) => {
          const total = numericColumns.reduce((sum, column) => {
            const value = row[column]
            const normalizedValue = value?.replace?.(/[$,]/g, "") ?? value
            const parsedValue = Number(normalizedValue ?? 0)
            return sum + (Number.isNaN(parsedValue) ? 0 : parsedValue)
          }, 0)

          return {
            ...row,
            [columnName]: total.toFixed(2),
          }
        })

        workingFields = [...workingFields, columnName]
        workingRows = enhancedRows
        enhancedCsv = Papa.unparse({
          fields: workingFields,
          data: workingRows,
        })
        appliedOperations += 1

        // Update the suggestion status
        const totalSuggestion = suggestions.find(
          (s) => s.id === "calculate-totals"
        )
        if (totalSuggestion) {
          totalSuggestion.status = "applied"
          totalSuggestion.preview = `New ${columnName} column now available in the spreadsheet`
        }
      }
    }

    if (operation === "clean_data") {
      let modifications = 0
      const cleanedRows = workingRows
        .map((row) => {
          const cleanedRow: Record<string, string> = {}
          for (const field of workingFields) {
            const current = row[field] ?? ""
            const cleaned = String(current).trim()
            if (cleaned !== current) {
              modifications += 1
            }
            cleanedRow[field] = cleaned
          }
          return cleanedRow
        })
        .filter((row) => {
          const keep = Object.values(row).some(
            (value) => !isNullishOrEmpty(value)
          )
          if (!keep) {
            modifications += 1
          }
          return keep
        })

      if (modifications > 0 || cleanedRows.length !== workingRows.length) {
        workingRows = cleanedRows
        enhancedCsv = Papa.unparse({
          fields: workingFields,
          data: workingRows,
        })
        appliedOperations += 1

        const cleanSuggestion = suggestions.find((s) => s.id === "clean-data")
        if (cleanSuggestion) {
          cleanSuggestion.status = "applied"
          cleanSuggestion.preview = "Data cleaned and normalized"
        }
      }
    }

    if (operation === "filter_rows" && _filterCriteria) {
      const predicate = buildFilterPredicate(_filterCriteria, workingFields)
      const filterSuggestion = suggestions.find((s) => s.id === "filter-rows")

      if (predicate) {
        const filteredRows = workingRows.filter(predicate)

        if (filteredRows.length !== workingRows.length) {
          workingRows = filteredRows
          enhancedCsv = Papa.unparse({
            fields: workingFields,
            data: workingRows,
          })
          appliedOperations += 1

          if (filterSuggestion) {
            filterSuggestion.status = "applied"
            filterSuggestion.preview = `Rows filtered (${workingRows.length} remaining)`
          }
        } else if (filterSuggestion) {
          filterSuggestion.status = "skipped"
          filterSuggestion.preview = "Filter criteria matched all rows"
        }
      } else if (filterSuggestion) {
        filterSuggestion.status = "skipped"
        filterSuggestion.preview = "Could not parse filter criteria"
      }
    }

    if (operation === "sort_data" && _sortBy) {
      const { index: sortIndex, name: sortField } = resolveColumnReference(
        _sortBy,
        workingFields
      )

      const sortSuggestion = suggestions.find((s) => s.id === "sort-data")

      if (sortIndex >= 0) {
        const orderMultiplier = _sortOrder === "desc" ? -1 : 1

        const sortedRows = [...workingRows].sort((a, b) => {
          const aValue = coerceValue(String(a[sortField] ?? ""))
          const bValue = coerceValue(String(b[sortField] ?? ""))

          if (
            typeof aValue === "number" &&
            typeof bValue === "number" &&
            !Number.isNaN(aValue) &&
            !Number.isNaN(bValue)
          ) {
            return (aValue - bValue) * orderMultiplier
          }

          if (typeof aValue === "boolean" && typeof bValue === "boolean") {
            return (Number(aValue) - Number(bValue)) * orderMultiplier
          }

          const comparison = String(aValue).localeCompare(
            String(bValue),
            undefined,
            {
              sensitivity: "base",
            }
          )

          return comparison * orderMultiplier
        })

        workingRows = sortedRows
        enhancedCsv = Papa.unparse({
          fields: workingFields,
          data: workingRows,
        })
        appliedOperations += 1

        if (sortSuggestion) {
          sortSuggestion.status = "applied"
          sortSuggestion.preview = `Sorted by ${sortField} (${_sortOrder})`
        }
      } else if (sortSuggestion) {
        sortSuggestion.status = "skipped"
        sortSuggestion.preview = "Unable to resolve sort column"
      }
    }

    if (operation === "edit_column" && _editColumn && _editInstruction) {
      console.log("🔧 EXECUTING EDIT COLUMN")
      console.log("📝 Target Column:", _editColumn)
      console.log("📝 Instruction:", _editInstruction)
      console.log("📊 Available Fields:", workingFields)

      const { index: targetColumnIndex, name: targetColumnName } =
        resolveColumnReference(_editColumn, workingFields)

      console.log(
        "🧭 Resolved column reference:",
        targetColumnIndex,
        targetColumnName
      )

      if (targetColumnIndex >= 0 && targetColumnIndex < workingFields.length) {
        console.log("✅ Column found! Processing edits...")

        // Apply the edit instruction to the column data
        const replacementInstruction =
          extractReplacementInstruction(_editInstruction)

        console.log("🔄 Replacement instruction:", replacementInstruction)

        let modifiedCount = 0
        const editedRows = workingRows.map((row) => {
          const currentValue = row[workingFields[targetColumnIndex]] || ""
          let newValue = currentValue

          // Simple transformation examples based on common instructions
          if (
            _editInstruction.toLowerCase().includes("uppercase") ||
            _editInstruction.toLowerCase().includes("capitalize")
          ) {
            newValue = currentValue.toUpperCase()
          } else if (_editInstruction.toLowerCase().includes("lowercase")) {
            newValue = currentValue.toLowerCase()
          } else if (_editInstruction.toLowerCase().includes("title case")) {
            newValue = currentValue.replace(
              /\w\S*/g,
              (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
            )
          } else if (_editInstruction.toLowerCase().includes("trim")) {
            newValue = currentValue.trim()
          } else if (_editInstruction.toLowerCase().includes("add prefix")) {
            const prefix = _editInstruction.match(PREFIX_REGEX)?.[1] || ""
            newValue = prefix + currentValue
          } else if (_editInstruction.toLowerCase().includes("add suffix")) {
            const suffix = _editInstruction.match(SUFFIX_REGEX)?.[1] || ""
            newValue = currentValue + suffix
          } else if (replacementInstruction) {
            const fromValue = replacementInstruction.from
            const toValue = replacementInstruction.to

            if (fromValue) {
              const normalizedCurrent = currentValue.trim()
              if (normalizedCurrent.toLowerCase() === fromValue.toLowerCase()) {
                newValue = toValue
              } else if (currentValue.includes(fromValue)) {
                newValue = currentValue.replace(fromValue, toValue)
              }
            }
          }

          if (newValue !== currentValue) {
            modifiedCount += 1
          }

          return {
            ...row,
            [workingFields[targetColumnIndex]]: newValue,
          }
        })

        if (modifiedCount > 0) {
          workingRows = editedRows
          enhancedCsv = Papa.unparse({
            fields: workingFields,
            data: workingRows,
          })
          appliedOperations += 1

          const editSuggestion = suggestions.find((s) => s.id === "edit-column")
          if (editSuggestion) {
            editSuggestion.status = "applied"
            editSuggestion.preview = `Updated ${targetColumnName} column data`
          }
        } else {
          const editSuggestion = suggestions.find((s) => s.id === "edit-column")
          if (editSuggestion) {
            editSuggestion.status = "skipped"
            editSuggestion.preview = "No matching cells found for update"
          }
        }
      }
    }

    if (operation === "merge_data" && csv && csv.trim()) {
      console.log("🔗 EXECUTING MERGE DATA")
      console.log("📊 Strategy:", mergeStrategy)
      console.log("📄 New CSV length:", csv.length)
      console.log("📊 Existing data rows:", workingRows.length)
      console.log("📊 Existing fields:", workingFields.length)

      try {
        const newParseResult = parseCsvWithFallback(csv, workingFields)
        const normalizedNewRows = normalizeRowsToFields(
          newParseResult.rows,
          newParseResult.fields,
          workingFields
        )

        console.log(
          "📊 New data - Fields:",
          newParseResult.fields.length,
          "Rows:",
          normalizedNewRows.length
        )

        if (normalizedNewRows.length > 0) {
          const previousCount = workingRows.length
          let mergedRows: Record<string, string>[] = []

          switch (mergeStrategy) {
            case "prepend":
              mergedRows = [...normalizedNewRows, ...workingRows]
              break
            case "insert_at_index":
              mergedRows = [...workingRows, ...normalizedNewRows]
              break
            default:
              mergedRows = [...workingRows, ...normalizedNewRows]
              break
          }

          console.log("📊 Final merged rows:", mergedRows.length)

          workingRows = mergedRows
          enhancedCsv = Papa.unparse({
            fields: workingFields,
            data: workingRows,
          })
          appliedOperations += 1

          const mergeSuggestion = suggestions.find(
            (s) => s.id === "merge-data" || s.id === "merge-data-fallback"
          )
          if (mergeSuggestion) {
            mergeSuggestion.status = "applied"
            mergeSuggestion.preview = `Added ${normalizedNewRows.length} new rows to dataset (${previousCount} → ${workingRows.length} total rows)`
          }

          console.log("✅ Merge completed successfully")
          console.log("📊 Final CSV length:", enhancedCsv.length)
        } else {
          console.log("⚠️ No valid rows found in new data")
          const mergeSuggestion = suggestions.find(
            (s) => s.id === "merge-data" || s.id === "merge-data-fallback"
          )
          if (mergeSuggestion) {
            mergeSuggestion.status = "skipped"
            mergeSuggestion.preview = "No valid rows found in new data"
          }
        }
      } catch (error) {
        console.error("❌ Merge error:", error)
        const mergeSuggestion = suggestions.find(
          (s) => s.id === "merge-data" || s.id === "merge-data-fallback"
        )
        if (mergeSuggestion) {
          mergeSuggestion.status = "skipped"
          mergeSuggestion.preview = `Error parsing new data: ${error instanceof Error ? error.message : String(error)}`
        }
      }
    }

    // Mark all suggestions as applied if we have operations
    if (appliedOperations > 0) {
      for (const suggestion of suggestions) {
        if (suggestion.status === "applying") {
          suggestion.status = "applied"
        }
      }
    }

    if (appliedOperations > 0) {
      const finalFields = workingFields
      const finalRows = workingRows

      const finalColumnProfiles = finalFields.map((field) => {
        const values = finalRows.map((row) => row[field] ?? "")
        const inferredType = detectColumnType(values)
        const filled =
          values.filter((value) => !isNullishOrEmpty(value)).length /
          (values.length || 1)
        const examples = Array.from(
          new Set(values.filter((value) => !isNullishOrEmpty(value)))
        ).slice(0, 3)

        return {
          name: field,
          inferredType,
          filled,
          examples,
        }
      })

      const finalSummarySample = finalRows
        .slice(0, 3)
        .map((row) => ({ ...row }))

      latestSummary = {
        rowCount: finalRows.length,
        columnCount: finalFields.length,
        sampleRows: finalSummarySample,
        columnProfiles: finalColumnProfiles,
      }
    }

    const updatedVersions = [
      ...startingVersions,
      {
        version: startingVersions.length + 1,
        label:
          appliedOperations > 0
            ? `${operationDescription} applied`
            : "Profiled dataset",
        csvContent: enhancedCsv,
        createdAt: Date.now(),
        description: operationDescription,
        operations: suggestions.map((s) => s.id),
      },
    ]

    // Stream final changes
    await table.update({
      stage: "applying_changes",
      progress: 0.8,
      csvContent: enhancedCsv,
      operations: suggestions,
      versions: updatedVersions,
      summary: latestSummary,
      currentOperation: {
        id: `operation-${Date.now()}`,
        label: operationDescription,
        progress: 0.8,
      },
    })

    await delay(300)

    // Stream completion
    await table.update({
      stage: "complete",
      progress: 0.95,
      currentOperation: {
        id: `operation-${Date.now()}`,
        label: "Finalizing changes",
        progress: 0.95,
      },
    })

    await delay(200)

    const finalData = {
      title: title ?? existingData?.title ?? "AI Table Editor",
      stage: "complete" as const,
      progress: 1,
      csvContent: enhancedCsv,
      summary: latestSummary ?? existingData?.summary ?? table.data.summary,
      operations: [...(existingData?.operations ?? []), ...suggestions],
      versions: updatedVersions,
      currentOperation: undefined,
    }

    console.log("🏁 FINALIZING ARTIFACT")
    console.log("📊 Final CSV length:", enhancedCsv.length)
    console.log("📊 Applied operations:", appliedOperations)
    console.log("📊 Final versions count:", updatedVersions.length)
    console.log("🆔 Artifact ID:", table.id)

    await table.complete(finalData)
    console.log("✅ Artifact completed successfully")

    // Save the current artifact data to context for future updates
    const finalVersion = streamInternal.instance?.version ?? previousVersion

    setCurrentArtifactData({
      artifactId: table.id,
      artifactVersion: finalVersion,
      csvContent: enhancedCsv,
      summary: finalData.summary,
      operations: finalData.operations,
      versions: updatedVersions,
      title: finalData.title,
      stage: "complete",
      progress: 1,
    })
    console.log("💾 Artifact data saved to context")

    const operationText =
      operation === "create"
        ? `Created table editor for ${title ?? "your dataset"}`
        : `Applied ${operationDescription.toLowerCase()} to the table`

    console.log("🎯 OPERATION COMPLETE:", operationText)
    console.log("🔧 TABLE EDITOR TOOL EXECUTION END")

    return {
      text: `${operationText} (User: ${user.fullName} - ${user.id}). ${
        dataRows.length
      } rows processed across ${fields.length} columns. ${appliedOperations} operations applied.`,
      parts: [
        {
          type: `data-artifact-${TableEditorArtifact.id}`,
          data: {
            id: table.id,
            version: finalVersion,
            status: "complete" as const,
            progress: 1,
            payload: finalData,
            createdAt: Date.now(),
          },
        },
      ],
    }
  },
})

const generateColumnName = async (
  instructions: string[],
  numericColumns: string[],
  operation: string
): Promise<string> => {
  try {
    const result = await generateText({
      model: "openai/gpt-5-nano",
      prompt: `You are a data analyst helping to generate meaningful column names for spreadsheet operations.

Context:
- Operation: ${operation}
- Numeric columns being calculated: ${numericColumns.join(", ")}
- User instructions: ${instructions.join("; ")}

Generate a single, descriptive column name that:
1. Reflects what the user is asking for in their instructions
2. Makes sense given the operation type and existing column names
3. Uses snake_case format (e.g., "total_revenue", "net_profit", "average_salary")
4. Is concise but descriptive
5. Avoids generic names like "calculated_value" or "new_column"

Examples:
- If calculating total of revenue columns: "total_revenue"
- If calculating difference between cost and revenue: "net_profit" 
- If calculating average of salary columns: "average_salary"
- If user says "add bonus column": "bonus"
- If user says "calculate total compensation": "total_compensation"

Return only the column name, nothing else.`,
    })

    const columnName = result.text.trim().replace(/\s+/g, "_")

    // Validate the generated name
    if (columnName && columnName.length > 0 && columnName.length < 50) {
      return columnName
    }
  } catch (error) {
    console.warn("Failed to generate column name with AI:", error)
  }

  // Fallback to simple logic if AI generation fails
  if (instructions.length > 0) {
    const instruction = instructions[0].toLowerCase()
    if (instruction.includes("total") || instruction.includes("sum")) {
      return "total"
    }
    if (instruction.includes("average") || instruction.includes("mean")) {
      return "average"
    }
    if (instruction.includes("difference") || instruction.includes("diff")) {
      return "difference"
    }
  }

  // Final fallback based on operation
  if (operation === "calculate") {
    return "calculated_total"
  }
  if (operation === "add_column") {
    return "new_column"
  }

  return "calculated_value"
}
ai-artifact-table
