import { cite } from 'rag-cite';

const report = await cite(
  'Paris is the capital of France [1]. It has about 2.1 million residents [2].',
  [
    { id: '1', content: 'Paris is the capital and largest city of France.' },
    { id: '2', content: 'The population of Paris is approximately 2.16 million inhabitants.' },
  ],
);

console.log(report.scores.grounding);   // 1.0  -- all claims grounded
console.log(report.scores.accuracy);    // 1.0  -- all citations correct
console.log(report.scores.quality);     // ~0.95
console.log(report.claimCount);         // 2
console.log(report.unattributed);       // []   -- no unattributed claims
console.log(report.phantom);            // []   -- no phantom citations

import { cite } from 'rag-cite';

const report = await cite(
  'The Eiffel Tower was completed in 1889 [1].',
  [{ id: '1', content: 'The Eiffel Tower was completed in 1889 for the World Fair.' }],
  { attributionThreshold: 0.4 },
);

import { extractCitations } from 'rag-cite';

const citations = extractCitations('Revenue grew [1]. Profits also rose [2, 3].');
// citations[0] => { format: 'numbered', id: '1', ... }
// citations[1] => { format: 'numbered', id: '2', ... }
// citations[2] => { format: 'numbered', id: '3', ... }

import { extractClaims } from 'rag-cite';

const claims = extractClaims('Paris is the capital. What about London? I hope this helps!');

const factual = claims.filter(c => c.isFactual);
// factual => [{ text: 'Paris is the capital', isFactual: true, ... }]

import { attribute } from 'rag-cite';

const result = await attribute(
  'Paris is the capital of France.',
  [{ id: '1', content: 'Paris is the capital and largest city of France.' }],
);

console.log(result.text);
// 'Paris is the capital of France [1].'

console.log(result.insertedCitations);
// [{ marker: '[1]', source: { id: '1', ... }, offset: 30, claim: { ... } }]

import { createCiter } from 'rag-cite';

const citer = createCiter({
  attributionThreshold: 0.5,
  claimGranularity: 'clause',
});

const report = await citer.cite(response, sources);
const annotated = await citer.attribute(response, sources);
const citations = citer.extractCitations(response);
const claims = citer.extractClaims(response);

interface CiteOptions {
  /** Minimum composite score to count as attributed. Default: 0.4 */
  attributionThreshold?: number;

  /** Minimum Levenshtein-based score to register as a fuzzy match. Default: 0.8 */
  fuzzyThreshold?: number;

  /** Minimum n-gram overlap to register. Default: 0.3 */
  ngramThreshold?: number;

  /** Minimum TF-IDF cosine to register. Default: 0.3 */
  tfidfThreshold?: number;

  /** Minimum embedding cosine to register. Default: 0.8 */
  embeddingThreshold?: number;

  /** Strategy weights for composite scoring. */
  weights?: {
    exact?: number;    // Default: 0.40 (0.30 with embedder)
    fuzzy?: number;    // Default: 0.25 (0.15 with embedder)
    ngram?: number;    // Default: 0.20 (0.15 with embedder)
    tfidf?: number;    // Default: 0.15 (0.10 with embedder)
    embedding?: number; // Default: 0.00 (0.30 with embedder)
  };

  /** Score weights for overall quality calculation. */
  scoreWeights?: {
    grounding?: number;    // Default: 0.35
    accuracy?: number;     // Default: 0.30
    coverage?: number;     // Default: 0.15
    faithfulness?: number; // Default: 0.20
  };

  /** Embedding function for semantic matching. */
  embedder?: (text: string) => Promise<number[]> | number[];

  /** Custom citation patterns. */
  citationPatterns?: CitationPattern[];

  /** Enable auto-attribution for uncited claims. Default: true */
  autoAttribute?: boolean;

  /** Claim extraction granularity. Default: 'sentence' */
  claimGranularity?: 'sentence' | 'clause' | 'paragraph';

  /** Map citation identifiers to source chunk IDs. */
  sourceMap?: Record<string, string>;

  /** Custom stopwords for n-gram and TF-IDF computation. */
  stopwords?: string[];

  /** Maximum sources to compare per claim. Default: 50 */
  maxSourcesPerClaim?: number;
}

import { cite } from 'rag-cite';

const report = await cite(response, sources, {
  citationPatterns: [
    {
      name: 'curly-ref',
      pattern: /\{ref:(\w+)\}/g,
      extract: (match) => ({ format: 'custom', id: match[1] }),
    },
  ],
});

interface CitationPattern {
  name: string;
  pattern: RegExp;  // Must include the global flag
  extract: (match: RegExpMatchArray) => { format: string; id: string };
}

const report = await cite(response, sources, {
  sourceMap: {
    '1': 'doc-abc',  // Citation [1] resolves to source with id 'doc-abc'
    '2': 'doc-xyz',
  },
});

try {
  const report = await cite(response, sources, { embedder: myEmbedder });
} catch (err) {
  // Handle embedder failure
}

import { cite } from 'rag-cite';

const report = await cite(response, sources, {
  embedder: async (text) => {
    const response = await fetch('https://api.openai.com/v1/embeddings', {
      method: 'POST',
      headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
      body: JSON.stringify({ model: 'text-embedding-3-small', input: text }),
    });
    const data = await response.json();
    return data.data[0].embedding;
  },
  embeddingThreshold: 0.8,
});

const sources = [
  { id: '1', content: 'Paris is the capital of France.', embedding: [0.12, -0.34, ...] },
];

// Sentence-level (default) -- one claim per sentence
const report = await cite(response, sources, { claimGranularity: 'sentence' });

// Clause-level -- splits on coordinating conjunctions and semicolons
const report = await cite(response, sources, { claimGranularity: 'clause' });

// Paragraph-level -- one claim per paragraph
const report = await cite(response, sources, { claimGranularity: 'paragraph' });

const report = await cite(response, sources, {
  weights: {
    exact: 0.50,
    fuzzy: 0.20,
    ngram: 0.15,
    tfidf: 0.10,
    embedding: 0.05,
  },
});

const report = await cite(response, sources, {
  scoreWeights: {
    grounding: 0.50,
    accuracy: 0.20,
    coverage: 0.15,
    faithfulness: 0.15,
  },
});

import { createCiter } from 'rag-cite';

const citer = createCiter({
  attributionThreshold: 0.5,
  claimGranularity: 'clause',
  embedder: myEmbedder,
});

// Analyze multiple responses with the same settings
const report1 = await citer.cite(response1, sources1);
const report2 = await citer.cite(response2, sources2);

// Override specific options per call
const report3 = await citer.cite(response3, sources3, { attributionThreshold: 0.3 });

import type {
  SourceChunk,
  SourceMetadata,
  Citation,
  Claim,
  Attribution,
  CitationVerification,
  ClaimReport,
  CitationScores,
  CitationReport,
  CiteOptions,
  CitationPattern,
  Citer,
  AnnotatedResponse,
} from 'rag-cite';

interface SourceChunk {
  id: string;
  content: string;
  metadata?: SourceMetadata;
  embedding?: number[];
}

interface SourceMetadata {
  title?: string;
  url?: string;
  author?: string;
  year?: string | number;
  section?: string;
  page?: number;
  [key: string]: unknown;
}

interface Citation {
  format: 'numbered' | 'named' | 'parenthetical' | 'footnote' | 'url' | 'custom';
  id: string;
  startOffset: number;
  endOffset: number;
  coveredText: string;
  coveredStartOffset: number;
  coveredEndOffset: number;
  resolvedSource: SourceChunk | null;
}

interface Claim {
  text: string;
  sentences: string[];
  startOffset: number;
  endOffset: number;
  citations: Citation[];
  isFactual: boolean;
  index: number;
}

interface Attribution {
  source: SourceChunk;
  confidence: number;
  primaryMatchType: 'exact' | 'fuzzy' | 'ngram' | 'tfidf' | 'embedding';
  strategyScores: { exact: number; fuzzy: number; ngram: number; tfidf: number; embedding: number };
  matchEvidence: string | null;
  matchOffset?: { start: number; end: number };
}