'use strict';

/**
 * Example: PDF → per-page LLM processing.
 *
 * Demonstrates reading a PDF with `pdftotext -layout`, splitting the output
 * into pages on the form-feed character (\f), and feeding each page through
 * LLMOrbiter in a foreach loop with a simple prompt.
 *
 * Usage:
 *   OPENROUTER_API_KEY=sk-or-... node examples/pdf-pages.js
 *   node examples/pdf-pages.js --key sk-or-... --model <model>
 */

import { execFileSync } from 'child_process';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import dotenv from 'dotenv';

import { LLMOrbiter, OpenRouterProvider, defineTool, DirectReturnError } from '../src/index.js';

const __dirname = path.dirname(fileURLToPath(import.meta.url));
dotenv.config({ path: path.resolve(__dirname, '.env'), quiet: true });

// ─── Prompt logfile ─────────────────────────────────────────────────────────────
// Appends the full prompt of every LLM call so we can debug prompt composition.
const logFile = path.resolve(__dirname, 'prompts.log');
function logPrompt(prompt) {
    fs.appendFileSync(logFile, `\n${'='.repeat(80)}\n${new Date().toISOString()}\n${'='.repeat(80)}\n${prompt}\n`);
}

function logEntry(label, data) {
    fs.appendFileSync(logFile, `\n--- ${label} @ ${new Date().toISOString()} ---\n${typeof data === 'string' ? data : JSON.stringify(data, null, 2)}\n`);
}

// ─── CLI args ───────────────────────────────────────────────────────────────────
const args = process.argv.slice(2);
function getArg(flag) {
    const idx = args.indexOf(flag);
    return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
}

const apiKey = getArg('--key') || process.env.OPENROUTER_API_KEY;
//const model = getArg('--model') || '~deepseek/deepseek-flash-latest';
//const model = getArg('--model') || 'moonshotai/kimi-k3'; 
//const model = getArg('--model') || '~openai/gpt-terra-latest:floor'; 
//const model = getArg('--model') || '~openai/gpt-sol-latest:floor';
//const model = getArg('--model') || '~anthropic/claude-sonnet-latest';
//const model = getArg('--model') || 'google/gemini-3.8-flash';
const model = getArg('--model') || '~openai/gpt-luna-latest:floor';

const pdfPath = getArg('--pdf') || path.resolve(__dirname, 'invoice.pdf');

if (!apiKey) {
    console.error('Error: Missing API key. Set OPENROUTER_API_KEY in examples/.env or pass --key <api-key>');
    process.exit(1);
}

// ─── Accumulated manifest state ─────────────────────────────────────────────────
// Split into two parts that mirror the two tools, so the prompt sections match
// the tool names and don't confuse the LLM.
const manifestBasedata = {
    date: null,
    kLieferant: null,
    lieferantName: null,
    manifestNr: null,
    manifestType: null,
};
const manifestNotes = [];
const manifestItems = {
    items: [],
    pagesFrom: null,
    pagesTo: null,
};

// Current page being processed (set in the loop before each run).
let currentPage = 0;

// ─── Tools ──────────────────────────────────────────────────────────────────────
// A single tool with three strictly optional components. Only include the
// components that have new data for this batch; omit the rest.
const outputManifestTool = defineTool({
    name: 'output_manifest',
    description: 'Stores extracted invoice/delivery-note data: header metadata (basedata), notes, and product line items. Each component is strictly optional — only include the ones that carry new data.',
    strict: false,
    parameters: {
        type: 'object',
        additionalProperties: false,
        required: [],
        properties: {
            basedata: {
                anyOf: [
                    {
                        type: 'object',
                        additionalProperties: false,
                        properties: {
                            date: {
                                type: ['string', 'null'],
                                description: 'Document date (ISO 8601)',
                            },
                            kLieferant: {
                                type: ['number', 'null'],
                                description: 'Lieferant ID',
                            },
                            lieferantName: {
                                type: 'string',
                                description: 'Lieferant name',
                            },
                            manifestNr: {
                                type: ['string', 'null'],
                                description: 'Lieferscheinnummer or Rechnungsnummer',
                            },
                            manifestType: {
                                anyOf: [
                                    { type: 'string', enum: ['rechnung', 'lieferschein'] },
                                    { type: 'null' },
                                ],
                                description: 'Document type',
                            },
                        },
                    },
                    { type: 'null' },
                ],
                description: 'Header/metadata. Only include fields that are currently missing or changed.',
            },
            notes: {
                anyOf: [
                    { type: 'array', items: { type: 'string' } },
                    { type: 'null' },
                ],
                description: 'New noteworthy details (in German), for a human to double-check the result. Only include notes not already present.',
            },
            items: {
                anyOf: [
                    {
                        type: 'object',
                        additionalProperties: false,
                        properties: {
                            numberOfItemsToAdd: {
                                type: 'number',
                                description: 'Number of NEW line items being added in this call (not the running total). Helps you keep track of how many items you are adding.',
                            },
                            items: {
                                type: 'array',
                                description: 'Invoice/delivery product line items',
                                items: {
                                    type: 'object',
                                    additionalProperties: false,
                                    required: ['position', 'count', 'vpe', 'unit', 'articleName', 'liefArtNr', 'mwst', 'eknetto'],
                                    properties: {
                                        position: { type: 'number', description: 'Position' },
                                        count: { type: 'number', description: 'Quantity (Menge)' },
                                        vpe: {
                                            type: 'number',
                                            description: 'Packaging unit size (VPE). Default: 1. (count * vpe = total individual sellable items). A bulk pack like VE100 means vpe = 100.',
                                        },
                                        unit: { type: 'string', description: 'Unit of the individual sellable item (e.g. Stk., Beutel, Flasche, Box, Set). NEVER "VE" or "VPE".' },
                                        articleName: { type: 'string', description: 'Article name' },
                                        liefArtNr: { type: 'string', description: 'Supplier article number (Art. Nr.)' },
                                        mwst: {
                                            anyOf: [
                                                { type: 'string', enum: ['7', '19'] },
                                                { type: 'null' },
                                            ],
                                            description: 'VAT rate (no % sign); null if missing',
                                        },
                                        eknetto: {
                                            type: ['number', 'null'],
                                            description: 'Net price per item or per vpe in euro cents; null if missing; DO NOT USE THE TOTAL, USE THE PER PIECE PRICE',
                                        },
                                    },
                                },
                            },
                        },
                    },
                    { type: 'null' },
                ],
                description: 'New product line items. Only include items not already present.',
            },
        },
    },
    invoke: async (args) => {
        // 1. basedata — merge only the fields the LLM actually filled in.
        if (args.basedata && typeof args.basedata === 'object') {
            for (const key of ['date', 'kLieferant', 'lieferantName', 'manifestNr', 'manifestType']) {
                if (args.basedata[key] != null) manifestBasedata[key] = args.basedata[key];
            }
        }

        // 2. notes — accept an array of strings; dedupe so re-sent notes don't accumulate.
        if (Array.isArray(args.notes)) {
            for (const n of args.notes) {
                if (n && !manifestNotes.includes(n)) manifestNotes.push(n);
            }
        }

        // 3. items — add only NEW items (dedupe by position).
        if (args.items && typeof args.items === 'object' && Array.isArray(args.items.items)) {
            const existing = new Set(manifestItems.items.map((it) => it.position));
            for (const it of args.items.items) {
                if (!existing.has(it.position)) {
                    manifestItems.items.push({ ...it, page: currentPage });
                    existing.add(it.position);
                }
            }
            // numberOfItemsToAdd is intentionally ignored — it only helps the LLM
            // keep track of how many items it is adding in this call.
            // Track the page range the current items come from.
            const pages = manifestItems.items.map((it) => it.page).filter((p) => p != null);
            if (pages.length) {
                manifestItems.pagesFrom = Math.min(...pages);
                manifestItems.pagesTo = Math.max(...pages);
            }
        }

        // Stop the LLM loop and return the accumulated data to the caller.
        throw new DirectReturnError({
            basedata: manifestBasedata,
            notes: manifestNotes,
            items: manifestItems,
        });
    },
});

// ─── Base extraction prompt ─────────────────────────────────────────────────────
const BASE_PROMPT = `Extract metadata and product line items from the provided invoice or delivery note.
Call the output_manifest tool with the extracted data. Do not answer with plain text once extraction is complete.

Rules:
- manifestType: "rechnung" or "lieferschein". For "lieferschein", prices and taxes must be null.
- Exclude non-product lines (shipping, handling, etc.).
- Line items: Extract count, vpe (default: 1), liefArtNr, mwst (7 or 19), and eknetto per piece(euro cents).
- Match supplier against the provided list for kLieferant and lieferantName. For unknown suppliers, extract lieferantName and set kLieferant to null.
- Write notes strictly in German.
- The output_manifest tool has three strictly optional components: basedata, notes, items. Only include a component when it carries genuinely new data for this batch; omit the rest.
- Include basedata ONLY when at least one of its fields is currently null/empty and you can fill it in, or when a value actually changes. If all basedata fields are already set and unchanged, omit basedata.
- Include items ONLY when this batch contains new product line items not already present. If there are no new items, omit items.
- Include notes ONLY when there is a genuinely new noteworthy detail not already in the notes list. These notes are for a human to double-check the extraction result, so record anything ambiguous, unusual, or worth verifying (e.g. packaging interpretations, excluded lines, unavailable articles).

VPE (Verpackungseinheit) Logic:
VPE represents the number of individually sellable units inside a bulk item. If not explicitly split for individual sale, default to 1.
- "20 Boxen á 10 Stück" -> VPE = 20.
- "10 Gläser á 100 Filter" -> VPE = 10 (we sell the 10 glasses individually).
- "100 Stück" -> VPE = 1 (sold as one bulk pack).
- We don't sell the individual filters or Pieces, but typical VPEs like Beutel, Glässer, Boxen, Hefte
- That menas that in "Y Hefte á X Blatt" the VPE is NOT X but: Y
- a so called "Display" also means VPE. So "20er Display" means VPE = 20
- eknetto is the price of one full vpe

Unit (ME) rules:
- The unit (ME) must ALWAYS refer to the individual sellable item (e.g. Stk., Beutel, Flasche, Box, Set). It must NEVER be "VE" or "VPE".
- A packaging size like "VE100" means the bulk pack contains 100 individual items: set vpe = 100 and unit = the individual item (e.g. Stk.).
- Example: "Einhängesiebe Stahl, VE100" -> vpe = 100, unit = "Stk.", count = 1 (one bulk pack of 100 sieves).`;

// ─── Read PDF and split into pages ──────────────────────────────────────────────
function readPdfPages(file) {
    // pdftotext -layout preserves column layout; pages are separated by \f (form feed)
    const raw = execFileSync('pdftotext', ['-layout', file, '-'], { encoding: 'utf8' });
    // Split on form feed, drop any leading/trailing empty chunks
    return raw
        .split('\f')
        .map((p) => p.trim())
        .filter((p) => p.length > 0);
}

// ─── Write output table ─────────────────────────────────────────────────────────
// Meta base data at the top, then a table of the items.
function writeOutputTable() {
    const lines = [];

    lines.push('=== Manifest Base Data ===');
    lines.push(`Date:            ${manifestBasedata.date ?? ''}`);
    lines.push(`Lieferant ID:    ${manifestBasedata.kLieferant ?? ''}`);
    lines.push(`Lieferant Name:  ${manifestBasedata.lieferantName ?? ''}`);
    lines.push(`Manifest Nr:     ${manifestBasedata.manifestNr ?? ''}`);
    lines.push(`Manifest Type:   ${manifestBasedata.manifestType ?? ''}`);
    lines.push(`Number of Items: ${manifestItems.items.length}`);
    if (manifestNotes.length) {
        lines.push('Notes:');
        for (const n of manifestNotes) lines.push(`  - ${n}`);
    }

    lines.push('');
    lines.push('=== Items ===');
    const headers = ['Pos', 'Art. Nr.', 'Article Name', 'Count', 'VPE', 'Unit', 'MwSt', 'EK Netto (ct)'];
    const rows = manifestItems.items.map((it) => [
        it.position,
        it.liefArtNr,
        it.articleName,
        it.count,
        it.vpe,
        it.unit,
        it.mwst,
        it.eknetto,
    ]);

    // Column widths
    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i] ?? '').length)));
    const fmtRow = (cells) => cells.map((c, i) => String(c ?? '').padEnd(widths[i])).join('  ');

    lines.push(fmtRow(headers));
    lines.push(widths.map((w) => '-'.repeat(w)).join('  '));
    for (const r of rows) lines.push(fmtRow(r));

    const outFile = path.resolve(__dirname, 'outputTable.txt');
    fs.writeFileSync(outFile, lines.join('\n') + '\n');
    console.log(`\n📄 Wrote ${outFile}`);
}

// ─── Write verification JSON ────────────────────────────────────────────────────
// Manifest Nr, Manifest Type, and items (without article name / date) for
// verification. If the file already exists, report whether it is identical.
function writeVerificationJson() {
    const payload = {
        manifestNr: manifestBasedata.manifestNr,
        manifestType: manifestBasedata.manifestType,
        items: manifestItems.items.map((it) => ({
            position: it.position,
            liefArtNr: it.liefArtNr,
            count: it.count,
            vpe: it.vpe,
            mwst: it.mwst,
            eknetto: it.eknetto,
        })),
    };

    const outFile = path.resolve(__dirname, 'outputVerification.json');
    const json = JSON.stringify(payload, null, 2) + '\n';

    if (fs.existsSync(outFile)) {
        const existing = fs.readFileSync(outFile, 'utf8');
        if (existing === json) {
            console.log(`\n✅ ${outFile} already exists and is identical.`);
        } else {
            console.log(`\n⚠️  ${outFile} already exists but DIFFERS from the new result.`);
            printJsonDiff(existing, json);
        }
    } else {
        fs.writeFileSync(outFile, json);
        console.log(`\n📄 Wrote ${outFile}`);
    }
}

// ─── Print a structured diff between two verification JSONs ─────────────────────
// Parses both and compares item-by-item (keyed by position), showing the item's
// article number and exactly which fields differ.
function printJsonDiff(oldStr, newStr) {
    let oldObj, newObj;
    try {
        oldObj = JSON.parse(oldStr);
        newObj = JSON.parse(newStr);
    } catch {
        // Fall back to a plain line diff if JSON parsing fails.
        const oldLines = oldStr.split('\n');
        const newLines = newStr.split('\n');
        const max = Math.max(oldLines.length, newLines.length);
        console.log(`\n${'─'.repeat(60)}`);
        for (let i = 0; i < max; i++) {
            const a = oldLines[i];
            const b = newLines[i];
            if (a === b) continue;
            if (a === undefined) console.log(`  ${' '.repeat(3)}${b}`);
            else if (b === undefined) console.log(`- ${a}`);
            else { console.log(`- ${a}`); console.log(`+ ${b}`); }
        }
        console.log(`${'─'.repeat(60)}`);
        return;
    }

    console.log(`\n${'─'.repeat(60)}`);

    // Top-level scalar fields
    for (const key of ['manifestNr', 'manifestType']) {
        if (oldObj[key] !== newObj[key]) {
            console.log(`${key}: ${JSON.stringify(oldObj[key])} -> ${JSON.stringify(newObj[key])}`);
        }
    }

    // Items, keyed by position
    const oldItems = new Map((oldObj.items || []).map((it) => [it.position, it]));
    const newItems = new Map((newObj.items || []).map((it) => [it.position, it]));

    const allPositions = new Set([...oldItems.keys(), ...newItems.keys()]);
    for (const pos of [...allPositions].sort((a, b) => a - b)) {
        const o = oldItems.get(pos);
        const n = newItems.get(pos);
        if (!o) {
            console.log(`+ item ${pos} (${n.liefArtNr}) ADDED`);
            continue;
        }
        if (!n) {
            console.log(`- item ${pos} (${o.liefArtNr}) REMOVED`);
            continue;
        }
        const diffs = [];
        for (const key of ['liefArtNr', 'count', 'vpe', 'mwst', 'eknetto']) {
            if (o[key] !== n[key]) diffs.push(`${key}: ${JSON.stringify(o[key])} -> ${JSON.stringify(n[key])}`);
        }
        if (diffs.length) {
            console.log(`item ${pos} (${n.liefArtNr}):`);
            for (const d of diffs) console.log(`    ${d}`);
        }
    }

    console.log(`${'─'.repeat(60)}`);
}

// ─── Main ───────────────────────────────────────────────────────────────────────
async function main() {
    console.log(`Reading PDF: ${pdfPath}`);
    const pages = readPdfPages(pdfPath);
    console.log(`Found ${pages.length} page(s).\n`);

    const provider = new OpenRouterProvider({ apiKey });
    let llmCallStart = null;
    const orbiter = new LLMOrbiter(provider, {
        onLLMCall: (call) => {
            llmCallStart = Date.now();
            console.log(`🤖 LLM call: model="${call.model}" promptSize=${call.promptSize} messages=${call.messages}`);
        },
        onStatus: (status) => console.log(`⚡ ${status}`),
        onToolCall: (call) => {
            console.log(`🔧 Tool called: ${call.name}(${JSON.stringify(call.args)})`);
            logEntry(`TOOL CALL ${call.name}`, call.args);
        },
        onToolResult: (res) => logEntry(`TOOL RESULT ${res.name}`, res.result),
        onToolError: (err) => logEntry(`TOOL ERROR ${err.name}`, err.error),
        onUsage: (usage) => {
            const elapsed = llmCallStart != null ? ((Date.now() - llmCallStart) / 1000).toFixed(3) : '?';
            console.log(`📊 usage: in=${usage.input} cached=${usage.cached} out=${usage.output} cost=${usage.cost} (${elapsed}s)`);
        },
    });

    // Feed pages through LLMOrbiter. If there are fewer than 5 pages, process all
    // of them in a single run; otherwise batch them 3 pages per call.
    const batchSize = pages.length;//< 5 ? pages.length : 3;
    const numBatches = Math.ceil(pages.length / batchSize);

    for (let b = 0; b < numBatches; b++) {
        const start = b * batchSize;
        const end = Math.min(start + batchSize, pages.length);
        const batchPages = pages.slice(start, end);
        const firstPage = start + 1;
        const lastPage = end;

        currentPage = firstPage;
        console.log(`\n▸ Processing pages ${firstPage}-${lastPage}/${pages.length}...`);

        const itemPages = manifestItems.pagesFrom != null
            ? `page ${manifestItems.pagesFrom} to ${manifestItems.pagesTo}`
            : 'no items yet';

        const pageContent = batchPages
            .map((p, idx) => `--- Page ${firstPage + idx} of ${pages.length} ---\n${p}`)
            .join('\n\n');

        const prompt = `${BASE_PROMPT}

You are currently processing pages ${firstPage} to ${lastPage} of ${pages.length}.

Current manifest_basedata (fill in what is still missing):
${JSON.stringify(manifestBasedata, null, 2)}

Current notes (add only NEW notes not already present):
${JSON.stringify(manifestNotes, null, 2)}

Current manifest_items (add only NEW items not already present; current items are from ${itemPages}):
${JSON.stringify(manifestItems, null, 2)}

Page content (pages ${firstPage} to ${lastPage} of ${pages.length}):
${pageContent}`;

        logPrompt(prompt);

        const result = await orbiter.run({
            prompt,
            model,
            tools: [outputManifestTool],
        });
        logEntry(`LLM OUTPUT pages ${firstPage}-${lastPage}`, result.content);

        // The tool throws DirectReturnError to stop the loop and hand back the
        // accumulated data. If that happened, we're done — no more batches.
        if (result.directReturn) {
            console.log(`\n⏹️  Direct return after pages ${firstPage}-${lastPage}.`);
            break;
        }
    }

    console.log('\n✅ Done.');

    writeOutputTable();
    writeVerificationJson();
}

main().catch((err) => {
    console.error('FATAL:', err);
    process.exit(1);
});