/**
 * AI Service - Gemini-based implementation
 */

import { 
  GeminiModel,
  BentoCardData,
  BlogSection,
  ChatMessage,
  PaperStructure,
  SectionPlan,
  ValidationStatus,
  ChartData
} from '../types';

// Gemini functions
import {
  generateBentoCards as geminiGenerateBentoCards,
  expandBentoCard as geminiExpandBentoCard,
  chatWithDocument as geminiChatWithDocument,
  analyzePaperStructure as geminiAnalyzePaperStructure,
  generateSingleBlogSection as geminiGenerateSingleBlogSection,
  validateVisualization as geminiValidateVisualization,
  repairVisualization as geminiRepairVisualization,
  generateAndValidateSection as geminiGenerateAndValidateSection,
  // Legacy exports
  validateBlogSection as geminiValidateBlogSection,
  repairBlogSection as geminiRepairBlogSection
} from './geminiService';

/**
 * Generate Bento Cards
 */
export const generateBentoCards = async (
  apiKey: string,
  model: GeminiModel,
  content: string,
  isPdf: boolean = false,
  useThinking: boolean = false
): Promise<BentoCardData[]> => {
  return geminiGenerateBentoCards(apiKey, model, content, isPdf, useThinking);
};

/**
 * Expand Bento Card
 */
export const expandBentoCard = async (
  apiKey: string,
  model: GeminiModel,
  topic: string,
  detailPrompt: string,
  originalContext: string,
  useThinking: boolean = false
): Promise<string> => {
  return geminiExpandBentoCard(apiKey, model, topic, detailPrompt, originalContext, useThinking);
};

/**
 * Chat with Document
 */
export const chatWithDocument = async (
  apiKey: string,
  model: GeminiModel,
  history: ChatMessage[],
  newMessage: string,
  context: string
): Promise<string> => {
  return geminiChatWithDocument(apiKey, model, history, newMessage, context);
};

/**
 * Analyze Paper Structure
 */
export const analyzePaperStructure = async (
  apiKey: string,
  model: GeminiModel,
  content: string,
  isPdf: boolean = false,
  useThinking: boolean = false
): Promise<PaperStructure> => {
  return geminiAnalyzePaperStructure(apiKey, model, content, isPdf, useThinking);
};

/**
 * Generate Single Blog Section
 */
export const generateSingleBlogSection = async (
  apiKey: string,
  model: GeminiModel,
  content: string,
  sectionPlan: SectionPlan,
  sectionIndex: number,
  totalSections: number,
  paperContext: { title: string; abstract: string; mainContribution: string; keyTerms: string[] },
  isPdf: boolean = false,
  useThinking: boolean = false
): Promise<BlogSection> => {
  return geminiGenerateSingleBlogSection(
    apiKey, model, content, sectionPlan, sectionIndex,
    totalSections, paperContext, isPdf, useThinking
  );
};

/**
 * Validate visualization only (local syntax check)
 */
export const validateVisualization = (section: BlogSection): ValidationStatus => {
  return geminiValidateVisualization(section);
};

/**
 * Repair visualization using AI
 */
export const repairVisualization = async (
  apiKey: string,
  model: GeminiModel,
  section: BlogSection,
  validationErrors: string[],
  paperContent: string,
  isPdf: boolean = false
): Promise<{ visualizationData?: string; chartData?: ChartData }> => {
  return geminiRepairVisualization(apiKey, model, section, validationErrors, paperContent, isPdf);
};

/**
 * Validate Blog Section (legacy - now just validates visualization)
 */
export const validateBlogSection = async (
  apiKey: string,
  model: GeminiModel,
  section: BlogSection,
  sectionPlan: SectionPlan,
  paperContext: { title: string; abstract: string; mainContribution: string; keyTerms: string[] },
  paperContent: string,
  isPdf: boolean = false
): Promise<ValidationStatus> => {
  return geminiValidateBlogSection(
    apiKey, model, section, sectionPlan, paperContext, paperContent, isPdf
  );
};

/**
 * Repair Blog Section
 */
export const repairBlogSection = async (
  apiKey: string,
  model: GeminiModel,
  section: BlogSection,
  validationStatus: ValidationStatus & { correctedVisualization?: string },
  sectionPlan: SectionPlan,
  paperContext: { title: string; abstract: string; mainContribution: string; keyTerms: string[] },
  paperContent: string,
  isPdf: boolean = false
): Promise<BlogSection> => {
  return geminiRepairBlogSection(
    apiKey, model, section, validationStatus, sectionPlan, paperContext, paperContent, isPdf
  );
};

/**
 * Generate and Validate Section
 */
export const generateAndValidateSection = async (
  apiKey: string,
  model: GeminiModel,
  content: string,
  sectionPlan: SectionPlan,
  sectionIndex: number,
  totalSections: number,
  paperContext: { title: string; abstract: string; mainContribution: string; keyTerms: string[] },
  isPdf: boolean = false,
  useThinking: boolean = false,
  maxRepairAttempts: number = 2,
  onStatusUpdate?: (status: 'generating' | 'validating' | 'repairing' | 'complete', message: string) => void
): Promise<BlogSection> => {
  return geminiGenerateAndValidateSection(
    apiKey, model, content, sectionPlan, sectionIndex, totalSections,
    paperContext, isPdf, useThinking, maxRepairAttempts, onStatusUpdate
  );
};

// Model info
export const MODEL_INFO: Record<GeminiModel, { name: string; description: string; icon: string }> = {
  'gemini-2.5-flash': {
    name: 'Gemini 2.5 Flash',
    description: 'Fast & efficient',
    icon: '⚡'
  },
  'gemini-3-pro-preview': {
    name: 'Gemini 3 Pro',
    description: 'Advanced reasoning',
    icon: '🧠'
  }
};