import { and, desc, eq, inArray, ne } from "drizzle-orm"
import { createddocuments, statementallocations } from "../../../db/schema"
import { booleanField, idField, InputField, objectField, textField } from "../masterdataFields"
import { limitFromArgs, offsetFromArgs, paginatedResult, paginationProperties } from "../pagination"
import { McpContext, McpTool } from "../types"

const paymentStates = ["Offen", "Teilbezahlt", "Bezahlt", "Überbezahlt"]
const paymentField: InputField = {
    schema: { type: "string", enum: paymentStates },
    parse(value) {
        if (typeof value !== "string" || !paymentStates.includes(value)) throw new Error("Unbekannter Zahlungsstatus")
        return value
    },
}
const listFields = {
    state: textField(true), type: textField(true), customer: idField, project: idField,
    cancelled: booleanField, paymentStatus: paymentField,
    limit: { schema: paginationProperties.limit, parse: value => limitFromArgs({ limit: value }) },
    offset: { schema: paginationProperties.offset, parse: value => offsetFromArgs({ offset: value }) },
}
const money = (value: number) => Number(value.toFixed(2))

function documentAmount(document: any, advanceInvoices: any[]) {
    let net = 0, tax19 = 0, tax7 = 0, advanceAmount = 0
    for (const row of document.rows || []) {
        if (["pagebreak", "title", "text"].includes(row.mode)) continue
        const values = [row.quantity, row.price, row.discountPercent, row.taxPercent].map(value => Number(value ?? 0))
        if (!values.every(Number.isFinite)) throw new Error(`Beleg ${document.id}: ungültiger Positionsbetrag`)
        const [quantity, price, discount, tax] = values
        const rowNet = Number((quantity * price * (1 - discount / 100)).toFixed(3))
        net += rowNet
        if (tax === 19) tax19 += rowNet * 0.19
        if (tax === 7) tax7 += rowNet * 0.07
    }
    for (const id of document.usedAdvanceInvoices || []) {
        const row = advanceInvoices.find(invoice => invoice.id === id)?.rows?.find(row => row.advanceInvoiceData)
        if (row) advanceAmount += Number(row.price) * ((100 + Number(row.taxPercent)) / 100)
    }
    // Match the outgoing-document screen (useSum): round net, 19% and 7% separately.
    // Aggregating both tax buckets before rounding can falsely report a one-cent debt.
    return money(money(net) + money(tax19) + money(tax7) - advanceAmount)
}

export function outgoingDocumentStatus(document: any, paidAmount: number, cancellations: any[], advanceInvoices: any[]) {
    const amount = documentAmount(document, advanceInvoices)
    if (![amount, paidAmount].every(Number.isFinite)) throw new Error(`Beleg ${document.id}: Betrag kann nicht berechnet werden`)
    const openAmount = money(amount - paidAmount)
    const cancelled = cancellations.length > 0
    const applicable = document.state === "Gebucht" && ["invoices", "advanceInvoices"].includes(document.type) && !cancelled
    // Signed invoices and refunds use the same payment-direction comparison.
    const direction = Math.sign(amount) || 1
    const paymentStatus = !applicable ? null : openAmount === 0 ? "Bezahlt"
        : openAmount * direction < 0 ? "Überbezahlt" : paidAmount * direction > 0 ? "Teilbezahlt" : "Offen"
    return {
        id: document.id, type: document.type, documentNumber: document.documentNumber, documentDate: document.documentDate,
        state: document.state, customer: document.customer, project: document.project,
        cancelled, cancellationDocuments: cancellations.map(({ id, documentNumber }) => ({ id, documentNumber })),
        paymentStatus, amount, paidAmount: money(paidAmount), openAmount,
    }
}

async function statusesFor(context: McpContext, documents: Array<typeof createddocuments.$inferSelect>) {
    if (!documents.length) return []
    const ids = documents.map(document => document.id)
    const advanceIds = [...new Set(documents.flatMap(document => Array.isArray(document.usedAdvanceInvoices)
        ? document.usedAdvanceInvoices.filter(id => typeof id === "number" && Number.isSafeInteger(id) && id > 0) as number[] : []))]
    const [allocations, cancellations, advances] = await Promise.all([
        context.server.db.select({ createddocument: statementallocations.createddocument, amount: statementallocations.amount }).from(statementallocations)
            .where(and(eq(statementallocations.tenant, context.tenantId), eq(statementallocations.archived, false), inArray(statementallocations.createddocument, ids))),
        context.server.db.select({ id: createddocuments.id, createddocument: createddocuments.createddocument, documentNumber: createddocuments.documentNumber }).from(createddocuments)
            .where(and(eq(createddocuments.tenant, context.tenantId), eq(createddocuments.archived, false), eq(createddocuments.type, "cancellationInvoices"),
                ne(createddocuments.state, "Entwurf"), inArray(createddocuments.createddocument, ids))).orderBy(createddocuments.id),
        advanceIds.length ? context.server.db.select().from(createddocuments)
            .where(and(eq(createddocuments.tenant, context.tenantId), eq(createddocuments.archived, false), inArray(createddocuments.id, advanceIds))) : [],
    ])
    return documents.map(document => outgoingDocumentStatus(document,
        allocations.filter(allocation => allocation.createddocument === document.id).reduce((sum, allocation) => sum + Number(allocation.amount), 0),
        cancellations.filter(cancellation => cancellation.createddocument === document.id), advances))
}

export const outgoingStatusTools: McpTool[] = [
    {
        name: "accounting.outgoing_documents.status.get", title: "Ausgangsbelegstatus laden",
        description: "Lädt Buchungs-, Zahlungs- und Stornostatus mit Gesamtbetrag, zugeordneten Zahlungen und offenem Betrag. Zahlungsstatus gilt für gebuchte, nicht stornierte Rechnungen und Abschlagsrechnungen; sonst null. Ändert keine Belege oder Buchungen.",
        requiredPermissions: ["accounting.outgoing_documents.read"],
        inputSchema: { ...objectField({ id: idField }).schema, required: ["id"] },
        async handler(context, args) {
            const { id } = objectField({ id: idField }).parse(args, "arguments")
            if (id === undefined) throw new Error("id ist erforderlich")
            const documents = await context.server.db.select().from(createddocuments)
                .where(and(eq(createddocuments.id, id), eq(createddocuments.tenant, context.tenantId), eq(createddocuments.archived, false))).limit(1)
            if (!documents.length) throw new Error("Ausgangsbeleg nicht gefunden oder archiviert")
            const [status] = await statusesFor(context, documents)
            return { status }
        },
    },
    {
        name: "accounting.outgoing_documents.status.list", title: "Ausgangsbelege nach Status filtern",
        description: "Listet Status und Beträge aktiver Ausgangsbelege. Kombinierbare Filter: state (z. B. Entwurf/Gebucht), paymentStatus, cancelled, type, customer und project. Statusfilter werden vor der Pagination angewendet. Archivierte Zahlungen und Stornos zählen nicht.",
        requiredPermissions: ["accounting.outgoing_documents.read"], inputSchema: objectField(listFields).schema,
        async handler(context, args) {
            const input = objectField(listFields).parse(args, "arguments")
            const conditions = [eq(createddocuments.tenant, context.tenantId), eq(createddocuments.archived, false)]
            for (const key of ["state", "type", "customer", "project"]) {
                if (input[key] !== undefined) conditions.push(eq(createddocuments[key], input[key]))
            }
            const limit = limitFromArgs(input)
            const offset = offsetFromArgs(input)
            const query = (size: number, start: number) => context.server.db.select().from(createddocuments).where(and(...conditions))
                .orderBy(desc(createddocuments.createdAt), createddocuments.id).limit(size).offset(start)
            if (input.paymentStatus === undefined && input.cancelled === undefined) {
                return paginatedResult(await statusesFor(context, await query(limit + 1, offset)), input)
            }
            // Derived statuses need related payments/credit documents. Scan bounded batches so filtering
            // happens before pagination without loading an entire tenant's documents into memory.
            const rows: Awaited<ReturnType<typeof statusesFor>> = []
            let matched = 0
            for (let start = 0; ; start += 100) {
                const documents = await query(100, start)
                for (const status of await statusesFor(context, documents)) {
                    if (input.paymentStatus !== undefined && status.paymentStatus !== input.paymentStatus) continue
                    if (input.cancelled !== undefined && status.cancelled !== input.cancelled) continue
                    if (matched++ >= offset) rows.push(status)
                    if (rows.length > limit) return paginatedResult(rows, input)
                }
                if (documents.length < 100) return paginatedResult(rows, input)
            }
        },
    },
]