geminiAPI.js

import { GoogleGenerativeAI } from '@google/generative-ai';

const BACKEND_BASE_URL = (process.env.REACT_APP_BACKEND_URL || '').replace(/\/$/, '');

class GeminiService {
  constructor() {
    this.genAI = null;
    this.backendBase = BACKEND_BASE_URL;
    this.usingBackend = Boolean(this.backendBase);
  }

  setApiKey(apiKey) {
    this.genAI = new GoogleGenerativeAI(apiKey);
  }

  async requestBackend(path, payload) {
    if (!this.backendBase) {
      throw new Error('Backend URL not configured');
    }

    try {
      const response = await fetch(`${this.backendBase}${path}`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(payload),
      });

      const contentType = response.headers.get('content-type') || '';
      const isJson = contentType.includes('application/json');
      const data = isJson ? await response.json() : null;

      if (!response.ok) {
        const detail = data?.detail || data?.error || response.statusText;
        throw new Error(detail || 'Backend request failed');
      }

      return data ?? {};
    } catch (error) {
      throw new Error(error.message || 'Backend request failed');
    }
  }

  // Helper function to clean and parse AI responses
  cleanAndParseResponse(responseText) {
    // Remove markdown code blocks
    let cleanText = responseText.replace(/```json\s*/g, '').replace(/```\s*/g, '');
    
    // Try to extract JSON from the response
    const jsonMatch = cleanText.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      try {
        return JSON.parse(jsonMatch[0]);
      } catch (e) {
        console.warn('Failed to parse JSON:', e);
        return null;
      }
    }
    return null;
  }

  // Enhanced paraphrasing with literary styles
  async advancedParaphrase(text, options = {}) {
    const {
      mode = 'Literary',
      writingStyle = 'neutral',
      targetAudience = 'general',
      preserveDialogue = true,
    } = options;

    if (this.usingBackend) {
      return await this.requestBackend('/api/paraphrase/advanced', {
        text,
        mode,
        writingStyle,
        targetAudience,
        preserveDialogue,
      });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }
    
    let prompt = `Transform the following text with these specifications:
    - Literary Mode: ${mode}
    - Writing Style: ${writingStyle}
    - Target Audience: ${targetAudience}
    - Preserve Dialogue: ${preserveDialogue}
    
    Focus on:
    1. Enhancing literary quality while maintaining meaning
    2. Improving sentence variety and flow
    3. Elevating vocabulary appropriately
    4. Maintaining character voice consistency
    
    Text: "${text}"
    
    Provide ONLY the refined version without any explanations or formatting.`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      return {
        success: true,
        result: response.text().trim(),
        originalLength: text.length,
        newLength: response.text().length
      };
    } catch (error) {
      throw new Error(`Advanced paraphrasing failed: ${error.message}`);
    }
  }

  // Advanced grammar and style checking
  async checkGrammarAdvanced(text, level) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/grammar/check', { text, level });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    let analysisDepth;
    switch (level) {
      case 'basic':
        analysisDepth = 'Focus only on grammar errors and basic punctuation';
        break;
      case 'standard':
        analysisDepth = 'Check grammar, punctuation, style, and clarity issues';
        break;
      case 'comprehensive':
        analysisDepth = 'Comprehensive analysis including grammar, style, flow, consistency, and literary quality';
        break;
      case 'literary':
        analysisDepth = 'Literary analysis focusing on creative writing, narrative voice, character consistency, and artistic expression';
        break;
    }

    const prompt = `Perform a ${level} grammar and style analysis of the following text.
    
    ${analysisDepth}
    
    Text: "${text}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "overallScore": 85,
      "issues": [
        {
          "type": "Grammar",
          "severity": "critical",
          "originalText": "exact text with issue",
          "description": "explanation of the issue",
          "suggestion": "corrected version"
        }
      ],
      "readability": "Grade level or description",
      "sentenceVariety": "Assessment of sentence structure variety",
      "vocabularyLevel": "Assessment of vocabulary complexity",
      "passiveVoiceUsage": 15,
      "styleNotes": "Overall style assessment"
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        overallScore: 75,
        issues: [],
        readability: "Analysis completed successfully",
        sentenceVariety: "Standard variety observed",
        vocabularyLevel: "Appropriate for intended audience",
        passiveVoiceUsage: 0,
        styleNotes: "Text analyzed for style and structure"
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Grammar check failed: ${error.message}`);
    }
  }

  // Character analysis and development
  async analyzeCharacter(text, characterName, analysisType) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/character/analyze', {
        text,
        characterName,
        analysisType,
      });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    let analysisPrompt;
    switch (analysisType) {
      case 'voice':
        analysisPrompt = 'Analyze the character\'s unique voice, speech patterns, vocabulary, and dialogue style';
        break;
      case 'development':
        analysisPrompt = 'Analyze character development, growth, motivations, and character arc';
        break;
      case 'consistency':
        analysisPrompt = 'Check for consistency in character behavior, voice, and personality traits';
        break;
      case 'dialogue':
        analysisPrompt = 'Focus on dialogue quality, authenticity, and character-specific speech patterns';
        break;
      case 'backstory':
        analysisPrompt = 'Analyze implied backstory and suggest areas for character depth';
        break;
    }

    const prompt = `Analyze the character "${characterName}" in the following text.
    
    Focus: ${analysisPrompt}
    
    Text: "${text}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "traits": ["trait1", "trait2", "trait3"],
      "voiceTone": "description of speaking style",
      "speechPattern": "characteristic speech patterns",
      "vocabularyLevel": "assessment of vocabulary used",
      "emotionalRange": "range of emotions displayed",
      "developmentNotes": "character development observations",
      "inconsistencies": ["issue1", "issue2"],
      "strengths": ["strength1", "strength2"],
      "improvementAreas": ["area1", "area2"]
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        traits: ["Character analyzed"],
        voiceTone: "Analysis completed successfully",
        speechPattern: "Patterns identified",
        vocabularyLevel: "Appropriate level",
        emotionalRange: "Emotions observed",
        developmentNotes: "Character development noted",
        inconsistencies: [],
        strengths: ["Character strengths identified"],
        improvementAreas: ["Areas for development noted"]
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Character analysis failed: ${error.message}`);
    }
  }

  // Generate character enhancement suggestions
  async generateCharacterSuggestions(characterName, traits, focusArea) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/character/suggestions', {
        characterName,
        traits,
        focusArea,
      });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Generate creative enhancement suggestions for the character "${characterName}" with traits: ${traits.join(', ')}.
    
    Focus area: ${focusArea}
    
    Provide practical, creative suggestions for character development.
    
    Respond with ONLY a valid JSON array (no markdown formatting) in this exact format:
    [
      {
        "category": "Dialogue",
        "description": "detailed suggestion",
        "example": "example implementation"
      }
    ]`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      let suggestions = this.cleanAndParseResponse(response.text());
      if (!Array.isArray(suggestions)) {
        suggestions = [
          {
            category: "General Development",
            description: "Character enhancement suggestions generated",
            example: "See detailed analysis for specific recommendations"
          }
        ];
      }

      return { success: true, suggestions };
    } catch (error) {
      throw new Error(`Character suggestions failed: ${error.message}`);
    }
  }

  // Plot structure analysis
  async analyzePlotStructure(text, plotType, directives = '') {
    if (this.usingBackend) {
      return await this.requestBackend('/api/plot/analyze', { text, plotType, directives });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    let structureGuide;
    switch (plotType) {
      case 'three-act':
        structureGuide = 'Three-Act Structure: Setup (25%), Confrontation (50%), Resolution (25%)';
        break;
      case 'heros-journey':
        structureGuide = "Hero's Journey: Ordinary World, Call to Adventure, Refusal, Meeting Mentor, Crossing Threshold, Tests, Ordeal, Reward, Road Back, Resurrection, Return";
        break;
      case 'seven-point':
        structureGuide = 'Seven-Point Structure: Hook, Plot Turn 1, Pinch Point 1, Midpoint, Pinch Point 2, Plot Turn 2, Resolution';
        break;
      case 'freytag':
        structureGuide = "Freytag's Pyramid: Exposition, Rising Action, Climax, Falling Action, Denouement";
        break;
      case 'fichtean':
        structureGuide = 'Fichtean Curve: Series of crises building to climax';
        break;
      default:
        structureGuide = 'Custom analysis of narrative structure';
    }

    const directiveText = directives?.trim()
      ? `Additional directives for chapter planning: ${directives.trim()}\n\n`
      : '';

    const prompt = `Analyze the plot structure of the following story using ${structureGuide}.
    
    Text: "${text}"
    
    ${directiveText}Follow any explicit directives about chapter count or focus. If none are provided, produce a 12-chapter outline that fully covers the narrative arc.
    
    Deliver:
    1. A structure analysis highlighting acts/stages, turning points, pacing, conflict, character arcs, themes, and actionable recommendations.
    2. A chapter layout that distributes the story across the requested or default chapter count. Each chapter must include purpose, primary conflict/tension, and hooks, and should go beyond summarizing an act.
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "analysis": {
        "overallScore": 85,
        "structureSummary": "one paragraph overview",
        "stages": [
          {
            "name": "Act I – Setup",
            "focus": "what this stage accomplishes",
            "progressPercent": 25,
            "keyBeats": ["inciting incident", "turning point"],
            "notes": "analysis of strengths and risks"
          }
        ],
        "pacing": "assessment of story pacing",
        "conflict": "analysis of central conflict",
        "characterArc": "character development assessment",
        "themeDevelopment": "theme analysis",
        "themes": ["theme1", "theme2"],
        "recommendations": [
          {
            "priority": "high",
            "title": "recommendation title",
            "description": "detailed recommendation"
          }
        ]
      },
      "chapterLayout": [
        {
          "number": 1,
          "title": "Chapter title",
          "summary": "short synopsis",
          "purpose": "narrative purpose",
          "conflict": "primary tension",
          "hooks": ["hook1"],
          "tags": ["setup", "character"]
        }
      ]
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      const parsed = this.cleanAndParseResponse(response.text());

      const analysis = parsed?.analysis || {
        overallScore: 75,
        structureSummary: 'Plot structure analyzed successfully',
        stages: [
          {
            name: 'Structure Analysis',
            focus: 'Overview of acts and turning points',
            progressPercent: 75,
            keyBeats: ['Inciting Incident', 'Climax'],
            notes: 'Continue developing your story structure'
          }
        ],
        pacing: 'Pacing analysis completed',
        conflict: 'Conflict development noted',
        characterArc: 'Character development observed',
        themeDevelopment: 'Themes identified',
        themes: ['Perseverance'],
        recommendations: [
          {
            priority: 'medium',
            title: 'General Development',
            description: 'Continue refining your plot structure'
          }
        ]
      };

      const layout = Array.isArray(parsed?.chapterLayout)
        ? parsed.chapterLayout
        : Array.isArray(parsed?.chapters)
          ? parsed.chapters
          : [];

      return { success: true, analysis, chapters: layout };
    } catch (error) {
      throw new Error(`Plot analysis failed: ${error.message}`);
    }
  }

  // NEW: Manuscript Manager
  async analyzeManuscript(chapters) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/manuscript/analyze', { chapters });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Analyze this manuscript structure and provide insights:
    
    Chapters: ${JSON.stringify(chapters)}
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "overallProgress": 65,
      "totalWordCount": 50000,
      "averageChapterLength": 2500,
      "paceAnalysis": "analysis of pacing across chapters",
      "consistencyIssues": ["issue1", "issue2"],
      "suggestions": ["suggestion1", "suggestion2"],
      "readabilityScore": 85,
      "chapterInsights": [
        {
          "chapterNumber": 1,
          "strengths": ["strength1"],
          "improvements": ["improvement1"],
          "paceRating": "good"
        }
      ]
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        overallProgress: 0,
        totalWordCount: 0,
        averageChapterLength: 0,
        paceAnalysis: "Analysis in progress",
        consistencyIssues: [],
        suggestions: ["Continue writing your manuscript"],
        readabilityScore: 75,
        chapterInsights: []
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Manuscript analysis failed: ${error.message}`);
    }
  }

  // NEW: Scene Builder
  async analyzeScene(sceneText, sceneType) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/scene/analyze', { sceneText, sceneType });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Analyze this scene for conflict, tension, and effectiveness:
    
    Scene Type: ${sceneType}
    Scene Text: "${sceneText}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "conflictLevel": 85,
      "tensionRating": 90,
      "paceRating": 75,
      "dialogueQuality": 80,
      "characterDevelopment": 70,
      "conflictTypes": ["internal", "external"],
      "tensionTechniques": ["technique1", "technique2"],
      "strengths": ["strength1", "strength2"],
      "improvements": ["improvement1", "improvement2"],
      "suggestions": [
        {
          "type": "Conflict",
          "description": "suggestion description",
          "example": "example implementation"
        }
      ]
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        conflictLevel: 50,
        tensionRating: 50,
        paceRating: 50,
        dialogueQuality: 50,
        characterDevelopment: 50,
        conflictTypes: ["general"],
        tensionTechniques: ["basic tension"],
        strengths: ["Scene analyzed"],
        improvements: ["Continue developing"],
        suggestions: [
          {
            type: "General",
            description: "Scene analysis completed",
            example: "Continue refining your scene"
          }
        ]
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Scene analysis failed: ${error.message}`);
    }
  }

  async generateChapterDraft({ chapterTitle, outline, scenes, directives, mainCharacters = [], supportingCharacters = [] }) {
    if (!Array.isArray(scenes) || scenes.length === 0) {
      throw new Error('At least one scene is required to compose a chapter draft.');
    }

    const characterBlock = buildCharacterBlock(mainCharacters, supportingCharacters);

    if (this.usingBackend) {
      return await this.requestBackend('/api/chapter/draft', {
        chapterTitle,
        outline,
        scenes: scenes.map((scene, index) => ({
          title: scene.title || `Scene ${index + 1}`,
          type: scene.type || scene.sceneType || 'general',
          text: scene.text || '',
          notes: scene.notes || '',
        })),
        directives,
        mainCharacters: characterBlock.main,
        supportingCharacters: characterBlock.supporting,
      });
    }

    const fallbackDraft = {
      title: chapterTitle,
      summary: outline || 'Draft generated from available scenes.',
      sections: scenes.map((scene, index) => ({
        heading: scene.title || `Scene ${index + 1}`,
        objective: scene.notes || '',
        beats: [],
        text: (scene.text && scene.text.trim()) ? [scene.text.trim()] : [],
      })),
      styleNotes: directives ? [directives] : [
        'Draft assembled locally from scene text. Consider refining with the hosted backend for richer output.',
      ],
    };

    const fallbackPrompt = `${characterBlock.text}Compose a chapter draft for "${chapterTitle}" using the provided scenes.`;
    const fallbackPreview = JSON.stringify(fallbackDraft).slice(0, 400);

    return { success: true, draft: fallbackDraft, prompt: fallbackPrompt, responsePreview: fallbackPreview };
  }

  async generateScenePlan({ chapterTitle, outline, desiredScenes, directives, sceneFocus, mainCharacters = [], supportingCharacters = [] }) {
    if (!outline || !outline.trim()) {
      throw new Error('A chapter outline is required to plan scenes.');
    }

    const characterBlock = buildCharacterBlock(mainCharacters, supportingCharacters);

    if (this.usingBackend) {
      return await this.requestBackend('/api/scene/plan', {
        chapterTitle,
        chapterOutline: outline,
        desiredScenes,
        directives,
        sceneFocus,
        mainCharacters: characterBlock.main,
        supportingCharacters: characterBlock.supporting,
      });
    }

    const outlineLines = outline.split('\n').map(line => line.trim()).filter(Boolean);
    const totalScenes = desiredScenes || Math.max(3, Math.min(outlineLines.length, 6));
    const scenes = Array.from({ length: totalScenes }).map((_, index) => {
      const snippet = outlineLines[index] || outlineLines[outlineLines.length - 1] || outline;
      return {
        title: `${chapterTitle || 'Chapter'} – Scene ${index + 1}`,
        type: 'general',
        summary: snippet,
        purpose: 'Advance the chapter narrative.',
        beats: [],
        notes: directives || '',
        tone: '',
        length: 'medium',
        setting: '',
      };
    });

    const fallbackPrompt = `${characterBlock.text}Outline ${totalScenes} scenes for chapter "${chapterTitle || 'Untitled'}" based on the provided outline.`;
    const fallbackPreview = scenes.map(scene => scene.title).join(', ').slice(0, 400);

    return { success: true, scenes, prompt: fallbackPrompt, responsePreview: fallbackPreview };
  }

  async refineSceneText({ mode = 'expand', sceneTitle, sceneText, chapterTitle, chapterOutline, directives, targetWords, mainCharacters = [], supportingCharacters = [] }) {
    if (!sceneText || !sceneText.trim()) {
      throw new Error('Scene text is required to refine.');
    }

    const characterBlock = buildCharacterBlock(mainCharacters, supportingCharacters);

    if (this.usingBackend) {
      return await this.requestBackend('/api/scene/refine', {
        mode,
        sceneTitle,
        sceneText,
        chapterTitle,
        chapterOutline,
        directives,
        targetWords,
        mainCharacters: characterBlock.main,
        supportingCharacters: characterBlock.supporting,
      });
    }

    const words = sceneText.split(/\s+/).filter(Boolean);
    let text;
    if (mode === 'tighten') {
      const keep = Math.max(1, Math.floor(words.length * 0.75));
      text = words.slice(0, keep).join(' ');
    } else {
      text = `${sceneText}\n\n[Expand this scene with richer detail when connected to the backend.]`;
    }

    const fallbackPrompt = `${characterBlock.text}${mode === 'tighten' ? 'Tighten' : 'Expand'} the scene "${sceneTitle}".`;
    const fallbackPreview = text.slice(0, 400);

    return {
      success: true,
      scene: {
        title: sceneTitle,
        text,
        beats: [],
        notes: directives || '',
      },
      prompt: fallbackPrompt,
      responsePreview: fallbackPreview,
    };
  }

  // NEW: Readability Optimizer
  async analyzeReadability(text, targetAudience) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/readability/analyze', { text, targetAudience });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Analyze the readability of this text for target audience: ${targetAudience}
    
    Text: "${text}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "readabilityScore": 85,
      "gradeLevel": "8th Grade",
      "targetMatch": true,
      "wordComplexity": "appropriate",
      "sentenceLength": "good",
      "vocabularyLevel": "suitable",
      "improvements": [
        {
          "issue": "issue description",
          "suggestion": "how to fix",
          "example": "example fix"
        }
      ],
      "strengths": ["strength1", "strength2"],
      "optimizedVersion": "optimized text version"
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        readabilityScore: 75,
        gradeLevel: "General Adult",
        targetMatch: true,
        wordComplexity: "appropriate",
        sentenceLength: "good",
        vocabularyLevel: "suitable",
        improvements: [
          {
            issue: "Analysis completed",
            suggestion: "Continue refining text",
            example: "Keep developing your writing"
          }
        ],
        strengths: ["Text analyzed successfully"],
        optimizedVersion: text
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Readability analysis failed: ${error.message}`);
    }
  }

  // Existing methods with improved response handling...
  async paraphraseText(text, mode, customPrompt = '') {
    if (this.usingBackend) {
      return await this.requestBackend('/api/paraphrase', { text, mode, customPrompt });
    }

    if (!this.genAI) {
      throw new Error('API key not set. Please configure your Gemini API key.');
    }

    let prompt;
    switch (mode) {
      case 'Formal':
        prompt = `Rewrite the following text in a formal, professional tone while maintaining the original meaning. Provide ONLY the rewritten text without explanations: "${text}"`;
        break;
      case 'Academic':
        prompt = `Rewrite the following text in an academic, scholarly style with appropriate terminology. Provide ONLY the rewritten text: "${text}"`;
        break;
      case 'Simple':
        prompt = `Simplify the following text to make it easier to read and understand. Provide ONLY the simplified text: "${text}"`;
        break;
      case 'Creative':
        prompt = `Creatively rewrite the following text with fresh, original phrasing and style. Provide ONLY the creative version: "${text}"`;
        break;
      case 'Shorten':
        prompt = `Condense the following text while retaining all main points. Provide ONLY the shortened text: "${text}"`;
        break;
      case 'Expand':
        prompt = `Expand the following text by adding more detail and elaboration. Provide ONLY the expanded text: "${text}"`;
        break;
      case 'Custom':
        prompt = `${customPrompt}. Provide ONLY the result: "${text}"`;
        break;
      default:
        prompt = `Paraphrase the following text. Provide ONLY the paraphrased version: "${text}"`;
    }

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      const paraphrasedText = response.text().trim();

      return {
        success: true,
        result: paraphrasedText,
        originalLength: text.length,
        newLength: paraphrasedText.length
      };
    } catch (error) {
      throw new Error(`Paraphrasing failed: ${error.message}`);
    }
  }

  async summarizeText(text, length = 'medium') {
    if (this.usingBackend) {
      return await this.requestBackend('/api/summarize', { text, length });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    let prompt;
    switch (length) {
      case 'short':
        prompt = `Provide a brief summary (2-3 sentences) of the following text. Provide ONLY the summary: "${text}"`;
        break;
      case 'long':
        prompt = `Provide a detailed summary with key points and supporting details. Provide ONLY the summary: "${text}"`;
        break;
      default:
        prompt = `Provide a concise summary of the following text. Provide ONLY the summary: "${text}"`;
    }

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      const summary = response.text().trim();

      return {
        success: true,
        summary,
        originalLength: text.length,
        summaryLength: summary.length,
        compressionRatio: ((text.length - summary.length) / text.length * 100).toFixed(1)
      };
    } catch (error) {
      throw new Error(`Summarization failed: ${error.message}`);
    }
  }

  async analyzeTone(text) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/analyze-tone', { text });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Analyze the tone of the following text.
    
    Text: "${text}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "overallTone": "description",
      "sentiment": "positive",
      "confidence": "high",
      "emotions": ["emotion1", "emotion2"],
      "suggestions": "improvement suggestions"
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        overallTone: "Neutral tone detected",
        sentiment: "neutral",
        confidence: "medium",
        emotions: ["general"],
        suggestions: "Tone analysis completed successfully"
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Tone analysis failed: ${error.message}`);
    }
  }

  async getSynonyms(word, context) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/synonyms', { word, context });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Provide 8 synonyms for the word "${word}" in this context: "${context}". 
    Return ONLY a JSON array of synonyms: ["synonym1", "synonym2", "synonym3", "synonym4", "synonym5", "synonym6", "synonym7", "synonym8"]`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      let synonyms = this.cleanAndParseResponse(response.text());
      if (!Array.isArray(synonyms)) {
        synonyms = response.text().split(',').map(s => s.trim().replace(/['"]/g, '')).slice(0, 8);
      }

      return { success: true, synonyms };
    } catch (error) {
      throw new Error(`Synonyms failed: ${error.message}`);
    }
  }

  async humanizeText(text) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/humanize', { text });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Make the following AI-generated text sound more natural and human-written. Provide ONLY the humanized version without explanations:
    
    Text: "${text}"`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      return { success: true, result: response.text().trim() };
    } catch (error) {
      throw new Error(`Humanization failed: ${error.message}`);
    }
  }

  // Script Breakdown Analysis
  async analyzeScriptBreakdown(scriptText) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/script/breakdown', { scriptText });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Analyze this screenplay and identify production elements in these categories:
    - props: Physical items handled or seen
    - wardrobe: Clothing items and accessories
    - cast: Character names
    - locations: All settings and locations
    - sfx: Sound effects and audio elements
    - vehicles: Cars, trucks, planes, etc.
    - animals: Any animals mentioned
    - stunts: Physical action sequences
    - makeup: Special makeup requirements
    - equipment: Special filmmaking equipment needed
    - extras: Background performers needed
    
    Script:
    "${scriptText}"
    
    Respond with ONLY a valid JSON object (no markdown formatting) in this exact format:
    {
      "props": ["prop1", "prop2"],
      "wardrobe": ["item1", "item2"],
      "cast": ["character1", "character2"],
      "locations": ["location1", "location2"],
      "sfx": ["effect1", "effect2"],
      "vehicles": ["vehicle1", "vehicle2"],
      "animals": ["animal1", "animal2"],
      "stunts": ["stunt1", "stunt2"],
      "makeup": ["makeup1", "makeup2"],
      "equipment": ["equipment1", "equipment2"],
      "extras": ["extra1", "extra2"]
    }`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      
      const analysis = this.cleanAndParseResponse(response.text()) || {
        props: [],
        wardrobe: [],
        cast: [],
        locations: [],
        sfx: [],
        vehicles: [],
        animals: [],
        stunts: [],
        makeup: [],
        equipment: [],
        extras: []
      };

      return { success: true, analysis };
    } catch (error) {
      throw new Error(`Script breakdown failed: ${error.message}`);
    }
  }

  // Generate Shot List
  async generateShotList(scriptText) {
    if (this.usingBackend) {
      return await this.requestBackend('/api/script/shots', { scriptText });
    }

    if (!this.genAI) {
      throw new Error('API key not set');
    }

    const prompt = `Based on this screenplay, create a detailed shot list with appropriate camera setups.
    For each key moment in the script, suggest a specific shot with these technical details:
    - scene number
    - shot number
    - shot description
    - shot type (CU, MS, WS, etc.)
    - camera angle
    - camera movement
    - equipment needed
    - lens recommendation
    - estimated duration
    - frame rate
  
    Script:
    "${scriptText.substring(0, 15000)}"
  
    Generate at least 5 shots for this scene.
    Respond with ONLY a valid JSON array (no markdown formatting) in this exact format:
    [
      {
        "scene": "1",
        "shotNumber": "1",
        "description": "Description of the shot content",
        "type": "MS",
        "angle": "Eye Level",
        "movement": "Static",
        "equipment": "Tripod",
        "lens": "50mm",
        "framing": "Medium",
        "notes": "Additional technical notes",
        "duration": "5s",
        "frameRate": "24 fps"
      }
    ]`;

    try {
      const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
      const result = await model.generateContent(prompt);
      const response = await result.response;
      const responseText = response.text();
      
      console.log("Raw API response:", responseText.substring(0, 200) + "..."); // Debug logging
    
      let shots = this.cleanAndParseResponse(responseText);
    
      // Validate the response format
      if (!Array.isArray(shots)) {
        console.error("Invalid shot list format received:", shots);
        
        // Attempt recovery by searching for JSON array in the response
        const jsonArrayMatch = responseText.match(/\[\s*\{[\s\S]*\}\s*\]/);
        if (jsonArrayMatch) {
          try {
            shots = JSON.parse(jsonArrayMatch[0]);
          } catch (parseError) {
            console.error("Recovery attempt failed:", parseError);
            shots = [];
          }
        } else {
          shots = [];
        }
      }
    
      // Add unique IDs and default values for missing properties
      shots = shots.map(shot => ({
        id: Date.now() + Math.floor(Math.random() * 1000),
        scene: "1",
        shotNumber: "1",
        description: "Shot description",
        type: "MS",
        angle: "Eye Level",
        movement: "Static",
        equipment: "Tripod",
        lens: "50mm",
        framing: "Medium",
        notes: "",
        duration: "5s",
        frameRate: "24 fps",
        ...shot // Overwrite defaults with actual values if present
      }));

      return { success: true, shots };
    } catch (error) {
      console.error("Shot list generation error:", error);
      throw new Error(`Shot list generation failed: ${error.message}`);
    }
  }
}

export const geminiService = new GeminiService();
const normalizeCharacterList = (characters = []) => {
  if (!Array.isArray(characters)) return [];
  return characters
    .map(character => {
      if (!character) return null;
      if (typeof character === 'string') {
        return { name: character, description: '' };
      }
      const name = (character.name || '').toString().trim();
      if (!name) return null;
      return {
        name,
        description: (character.description || '').toString().trim(),
      };
    })
    .filter(Boolean);
};

const buildCharacterBlock = (mainCharacters = [], supportingCharacters = []) => {
  const main = normalizeCharacterList(mainCharacters);
  const supporting = normalizeCharacterList(supportingCharacters);
  if (!main.length && !supporting.length) {
    return { main, supporting, text: '' };
  }

  const render = (title, list) =>
    list.length
      ? `${title}:\n${list.map(({ name, description }) => `- ${name}${description ? ` — ${description}` : ''}`).join('\n')}`
      : '';

  const sections = [render('Main Characters', main), render('Supporting Characters', supporting)].filter(Boolean);
  return { main, supporting, text: sections.length ? `Character Brief:\n${sections.join('\n\n')}\n\n` : '' };
};