/**
 * PR Content Engine AI Pipeline
 *
 * Orchestrates AI generation for expert columns, press releases, bios, and media kits.
 * Uses company context as seed data for personalised content generation.
 */

import { generateWithAI } from '../../utils/aiProvider';
import { parseJsonFromAI } from './parseJsonFromAI';
import {
  buildExpertColumnPlanPrompt,
  buildExpertColumnPrompt,
  buildPressReleasePrompt,
  buildBioPrompt,
  buildMediaKitPrompt,
  buildNewsStoryPrompt,
  buildThoughtLeadershipPrompt,
  buildHeadlinePrompt,
  buildQuotePrompt,
  buildMediaOutreachPrompt,
  buildCalendarSuggestionPrompt,
  buildRepurposePrompt,
  buildWikipediaArticlePrompt,
  buildWikipediaNotabilityPrompt,
  buildWikipediaCitationPrompt,
  buildKnowledgePanelPrompt,
  buildKnowledgePanelOptimisationPrompt,
  buildKnowledgePanelSchemaPrompt,
  buildKPSummaryPrompt,
  buildKPSectionContentPrompt,
  buildKPInsightsPrompt,
  buildKPFAQsPrompt,
  PRContentInputs,
  PromptResult,
} from './prPrompts';

// ============================================
// TYPES
// ============================================

export interface PRPipelineResult {
  expertColumnPlan?: Record<string, any>;
  expertColumn?: Record<string, any>;
  pressRelease?: Record<string, any>;
  founderBio?: Record<string, any>;
  mediaKit?: Record<string, any>;
  pipelineVersion: string;
  provider: string;
  aiModel: string;
  tokensUsed: number;
  inputTokens: number;
  outputTokens: number;
  processingTimeMs: number;
  latencyMs: number;
  finishReason: string | null;
  apiKeyMasked: string | null;
  errors: string[];
}

// Helper to capture token metadata from AI result
function captureMetadata(result: any) {
  return {
    provider: result.provider || 'unknown',
    aiModel: result.model || 'unknown',
    tokensUsed: result.tokenUsage?.totalTokens || result.tokensUsed || 0,
    inputTokens: result.tokenUsage?.inputTokens || result.inputTokens || 0,
    outputTokens: result.tokenUsage?.outputTokens || result.outputTokens || 0,
    processingTimeMs: result.processingTimeMs || 0,
    latencyMs: result.latencyMs || 0,
    finishReason: result.finishReason || null,
    apiKeyMasked: result.keyUsed || null,
  };
}

// ============================================
// EXPERT COLUMN PLAN PIPELINE
// ============================================

export async function ExpertColumnPlanPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildExpertColumnPlanPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// SINGLE EXPERT COLUMN PIPELINE
// ============================================

export async function ExpertColumnPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildExpertColumnPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// ENHANCED EXPERT COLUMN PLAN WITH FULL CONTENT
// Generates plan + full content for each article
// ============================================

export interface ArticleWithContent {
  week: number;
  topic: string;
  headline: string;
  description: string;
  article?: {
    headline: string;
    introduction: string;
    mainContent: string;
    conclusion: string;
    authorBio: string;
    mediaSubmissionNotes: string;
    wordCount: number;
  };
}

export async function ExpertColumnPlanWithContentPipeline(
  inputs: PRContentInputs,
  onProgress?: (step: string, progress: number) => void,
  preferredProvider?: string,
  providerLock?: boolean
): Promise<{ name: string; numberOfWeeks: number; format: string; tone: string; articles: ArticleWithContent[]; _metadata?: any }> {
  const numberOfWeeks = (inputs as any).numberOfWeeks || 4;
  const format = inputs.format || 'article';
  const tone = inputs.tone || 'professional';
  const wordCount = inputs.wordCount || 800;

  // Step 1: Generate the content plan
  onProgress?.('Generating content plan...', 10);
  const planResult = await ExpertColumnPlanPipeline(inputs, preferredProvider, providerLock);

  if (!planResult || !planResult.topics || !Array.isArray(planResult.topics)) {
    throw new Error('Failed to generate content plan');
  }

  const topics = planResult.topics as Array<{ week: number; topic: string; headline: string; description: string }>;
  const articles: ArticleWithContent[] = [];

  // Step 2: Generate full content for each article
  const totalArticles = topics.length;

  for (let i = 0; i < topics.length; i++) {
    const topicInfo = topics[i];
    const progressPercent = 10 + Math.round((i / totalArticles) * 80);
    onProgress?.(`Generating article ${i + 1} of ${totalArticles}: "${topicInfo.headline}"`, progressPercent);

    // Generate full content for this article
    const articleInputs: PRContentInputs = {
      ...inputs,
      weekNumber: topicInfo.week,
      topic: topicInfo.topic,
      format,
      tone,
      wordCount,
    };

    try {
      const articleResult = await ExpertColumnPipeline(articleInputs, preferredProvider, providerLock);

      articles.push({
        week: topicInfo.week,
        topic: topicInfo.topic,
        headline: topicInfo.headline,
        description: topicInfo.description,
        article: {
          headline: articleResult.headline || topicInfo.headline,
          introduction: articleResult.introduction || '',
          mainContent: articleResult.mainContent || articleResult.body || '',
          conclusion: articleResult.conclusion || '',
          authorBio: articleResult.authorBio || '',
          mediaSubmissionNotes: articleResult.mediaSubmissionNotes || '',
          wordCount: articleResult.wordCount || wordCount,
        },
      });
    } catch (error: any) {
      console.error(`[PR AI] Failed to generate article for week ${topicInfo.week}:`, error.message);
      // Push article without content but with topic info
      articles.push({
        week: topicInfo.week,
        topic: topicInfo.topic,
        headline: topicInfo.headline,
        description: topicInfo.description,
        article: undefined,
      });
    }
  }

  onProgress?.('Finalizing...', 95);

  return {
    name: planResult.name || `${numberOfWeeks}-Week Expert Column Series`,
    numberOfWeeks,
    format,
    tone,
    articles,
    _metadata: planResult._metadata,
  };
}

// ============================================
// PRESS RELEASE PIPELINE
// ============================================

export async function PressReleasePipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildPressReleasePrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// BIO PIPELINE
// ============================================

export async function BioPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildBioPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  console.log('[PR AI] Bio generation raw response length:', result.content?.length, '| provider:', result.provider, '| model:', result.model);
  const parsed = parseJsonFromAI(result.content);
  if (!parsed || Object.keys(parsed).length === 0) {
    console.error('[PR AI] Bio generation: parseJsonFromAI returned empty/null. Raw content (first 500 chars):', result.content?.substring(0, 500));
  }
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// MEDIA KIT PIPELINE
// ============================================

export async function MediaKitPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildMediaKitPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  console.log('[PR AI] Media kit generation raw response length:', result.content?.length, '| provider:', result.provider, '| model:', result.model);
  const parsed = parseJsonFromAI(result.content);
  if (!parsed || Object.keys(parsed).length === 0) {
    console.error('[PR AI] Media kit generation: parseJsonFromAI returned empty/null. Raw content (first 500 chars):', result.content?.substring(0, 500));
  }
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// NEWS STORY PIPELINE
// ============================================

export async function NewsStoryPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildNewsStoryPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// THOUGHT LEADERSHIP PIPELINE
// ============================================

export async function ThoughtLeadershipPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildThoughtLeadershipPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// HEADLINE PIPELINE
// ============================================

export async function HeadlinePipeline(inputs: PRContentInputs & {
  contentTitle?: string;
  contentSummary?: string;
  contentType?: string;
  categories?: string[];
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildHeadlinePrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// QUOTE PIPELINE
// ============================================

export async function QuotePipeline(inputs: PRContentInputs & {
  contentId?: string;
  contentText?: string;
  quoteType?: string;
  tone?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildQuotePrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// MEDIA OUTREACH PIPELINE
// ============================================

export async function MediaOutreachPipeline(inputs: PRContentInputs & {
  outreachType?: string;
  linkedContentId?: string;
  linkedContentType?: string;
  recipientName?: string;
  recipientOrganization?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildMediaOutreachPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// CALENDAR SUGGESTION PIPELINE
// ============================================

export async function CalendarSuggestionPipeline(inputs: PRContentInputs & {
  frequency?: string;
  focusAreas?: string[];
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildCalendarSuggestionPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// REPURPOSE PIPELINE
// ============================================

export async function RepurposePipeline(inputs: PRContentInputs & {
  sourceId?: string;
  sourceType?: string;
  sourceContent?: string;
  targetFormat?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildRepurposePrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// WIKIPEDIA ARTICLE PIPELINE
// ============================================

export async function WikipediaArticlePipeline(inputs: PRContentInputs & {
  wikiArticleTopic?: string;
  wikiSectionNames?: string[];
  wikiExistingContent?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildWikipediaArticlePrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// WIKIPEDIA NOTABILITY PIPELINE
// ============================================

export async function WikipediaNotabilityPipeline(inputs: PRContentInputs, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildWikipediaNotabilityPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// WIKIPEDIA CITATION PIPELINE
// ============================================

export async function WikipediaCitationPipeline(inputs: PRContentInputs & {
  claims?: string[];
  articleContent?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildWikipediaCitationPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL PIPELINE
// ============================================

export async function KnowledgePanelPipeline(inputs: PRContentInputs & {
  kpPanelType?: string;
  kpCurrentData?: string;
  kpDesiredFields?: string[];
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKnowledgePanelPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL OPTIMISATION PIPELINE
// ============================================

export async function KnowledgePanelOptimisationPipeline(inputs: PRContentInputs & {
  kpCurrentData?: string;
  kpPanelType?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKnowledgePanelOptimisationPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL SCHEMA PIPELINE
// ============================================

export async function KnowledgePanelSchemaPipeline(inputs: PRContentInputs & {
  kpPanelType?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKnowledgePanelSchemaPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL SUMMARY PIPELINE
// ============================================

export async function KPSummaryPipeline(inputs: PRContentInputs & {
  kpTitle?: string;
  kpCategory?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKPSummaryPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL SECTION CONTENT PIPELINE
// ============================================

export async function KPSectionContentPipeline(inputs: PRContentInputs & {
  kpTitle?: string;
  sectionType?: string;
  sectionTitle?: string;
  existingContent?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKPSectionContentPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL INSIGHTS PIPELINE
// ============================================

export async function KPInsightsPipeline(inputs: PRContentInputs & {
  kpTitle?: string;
  kpCategory?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKPInsightsPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}

// ============================================
// KNOWLEDGE PANEL FAQ PIPELINE
// ============================================

export async function KPFAQsPipeline(inputs: PRContentInputs & {
  kpTitle?: string;
  kpCategory?: string;
}, preferredProvider?: string, providerLock?: boolean): Promise<Record<string, any> & { _metadata?: any }> {
  const { systemPrompt, userPrompt, maxTokens } = buildKPFAQsPrompt(inputs);
  const result = await generateWithAI(userPrompt, systemPrompt, maxTokens, undefined, 'json', preferredProvider as any, undefined, undefined, undefined, providerLock);
  const parsed = parseJsonFromAI(result.content) as Record<string, any>;
  return { ...parsed, _metadata: captureMetadata(result) };
}