import subprocess
import os
from pathlib import Path

def pdf_to_text(pdf_path: str, lang: str = "eng") -> str:
    """
    Convert a PDF invoice to text using Tesseract OCR.
    Handles both text-based PDFs and scanned image PDFs.
    """
    pdf_path = Path(pdf_path)
    temp_dir = Path("/tmp/invoice_processing")
    temp_dir.mkdir(exist_ok=True)

    # Convert PDF pages to images using pdftoppm (from poppler-utils)
    base_name = pdf_path.stem
    image_prefix = temp_dir / base_name

    subprocess.run([
        "pdftoppm", "-r", "300", "-png",
        str(pdf_path), str(image_prefix)
    ], check=True)

    # Run Tesseract OCR on each page image
    full_text = []
    for image_file in sorted(temp_dir.glob(f"{base_name}*.png")):
        txt_file = image_file.with_suffix(".txt")
        subprocess.run([
            "tesseract", str(image_file),
            str(txt_file.with_suffix("")),
            "-l", lang
        ], check=True)

        full_text.append(txt_file.read_text(encoding="utf-8"))

        # Clean up image file
        image_file.unlink()

    # Clean up text files
    for txt_file in temp_dir.glob(f"{base_name}*.txt"):
        txt_file.unlink()

    return "\n\n--- PAGE BREAK ---\n\n".join(full_text)


# Example usage
if __name__ == "__main__":
    text = pdf_to_text("invoices/sample_invoice.pdf")
    print(text)

import json
import requests

def extract_invoice_data(ocr_text: str, model: str = "qwen2.5:7b") -> dict:
    """
    Use a local LLM (via Ollama) to extract structured data
    from raw OCR text of an invoice.
    """
    prompt = f"""You are an invoice data extraction assistant.
    Extract the following fields from this invoice text and return
    them as a JSON object. If a field is not present, use null.

    Fields to extract:
    - vendor_name: The company issuing the invoice
    - invoice_number: The invoice ID/number
    - invoice_date: Date the invoice was issued (YYYY-MM-DD format)
    - due_date: Payment due date (YYYY-MM-DD format)
    - line_items: Array of objects with "description", "quantity",
      "unit_price", and "amount"
    - subtotal: Subtotal amount (number)
    - tax: Tax amount (number)
    - total: Total invoice amount (number)
    - currency: Currency code if present (e.g., USD, EUR)

    Return ONLY the JSON object, no explanation.

    Invoice text:
    {ocr_text}
    """

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False,
            "format": "json",
            "options": {"temperature": 0.1}
        }
    )

    return json.loads(response.json()["response"])


# Example usage
if __name__ == "__main__":
    ocr_text = """ACME SUPPLIES LLC
    INVOICE #INV-2026-0473
    Date: March 15, 2026
    Due: April 14, 2026
    ...
    Subtotal: $2,855.00
    Tax (8%): $228.40
    Total: $3,083.40
    """

    data = extract_invoice_data(ocr_text)
    print(json.dumps(data, indent=2))

def categorize_invoice(invoice_data: dict, chart_of_accounts: list[str],
                       model: str = "qwen2.5:7b") -> dict:
    """
    Categorize invoice line items to general ledger accounts.
    """
    accounts_str = "\n".join(f"- {acc}" for acc in chart_of_accounts)

    prompt = f"""You are an accounting assistant. Assign each line item
    in this invoice to the most appropriate general ledger account
    from this chart of accounts:

    {accounts_str}

    For each line item, return the description, amount, and assigned
    GL account as a JSON array. Only use accounts from the list above.

    Invoice data:
    {json.dumps(invoice_data, indent=2)}
    """

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False,
            "format": "json",
            "options": {"temperature": 0.1}
        }
    )

    return json.loads(response.json()["response"])


# Example chart of accounts
CHART_OF_ACCOUNTS = [
    "5000 - Office Supplies",
    "5100 - Office Equipment",
    "5200 - IT Services",
    "5300 - Professional Services",
    "5400 - Travel & Entertainment",
    "5500 - Utilities",
    "5600 - Marketing & Advertising",
    "5700 - Software & Subscriptions",
]

# Categorize the extracted invoice
categorized = categorize_invoice(data, CHART_OF_ACCOUNTS)

from datetime import datetime, timedelta

def reconcile_invoices(invoices: list[dict],
                       bank_transactions: list[dict],
                       tolerance: float = 1.00) -> dict:
    """
    Match extracted invoices to bank transactions by amount and date.

    Args:
        invoices: List of invoice dicts with 'total', 'vendor_name',
                  'invoice_date', 'invoice_number'
        bank_transactions: List of bank txns with 'amount', 'date',
                          'description'
        tolerance: Acceptable difference for fuzzy amount matching (dollars)

    Returns:
        Dict with 'matched', 'unmatched_invoices', 'unmatched_transactions'
    """
    matched = []
    unmatched_invoices = list(invoices)
    unmatched_transactions = list(bank_transactions)

    for invoice in invoices:
        for txn in bank_transactions:
            if txn in unmatched_transactions:
                # Match by amount (within tolerance)
                amount_diff = abs(invoice["total"] - abs(txn["amount"]))
                if amount_diff <= tolerance:
                    # Verify date proximity (within 30 days of invoice)
                    inv_date = datetime.strptime(
                        invoice["invoice_date"], "%Y-%m-%d"
                    )
                    txn_date = datetime.strptime(
                        txn["date"], "%Y-%m-%d"
                    )
                    if abs((txn_date - inv_date).days) <= 30:
                        matched.append({
                            "invoice_number": invoice["invoice_number"],
                            "vendor": invoice["vendor_name"],
                            "invoice_amount": invoice["total"],
                            "bank_amount": txn["amount"],
                            "amount_difference": amount_diff,
                            "bank_date": txn["date"],
                            "bank_description": txn["description"],
                            "status": "matched"
                        })
                        unmatched_invoices.remove(invoice)
                        unmatched_transactions.remove(txn)
                        break

    return {
        "matched": matched,
        "unmatched_invoices": unmatched_invoices,
        "unmatched_transactions": unmatched_transactions,
        "match_rate": len(matched) / len(invoices) if invoices else 0
    }


# Example: reconcile a batch of invoices against bank transactions
invoices = [
    {"invoice_number": "INV-2026-0473", "vendor_name": "ACME SUPPLIES LLC",
     "total": 3083.40, "invoice_date": "2026-03-15"},
    {"invoice_number": "INV-2026-0512", "vendor_name": "TechFlow Services",
     "total": 1200.00, "invoice_date": "2026-03-18"},
]

bank_txns = [
    {"amount": 3083.40, "date": "2026-03-20",
     "description": "ACME SUPPLIES PAYMENT"},
    {"amount": 1198.00, "date": "2026-03-22",
     "description": "TECHFLOW SVC"},
]

result = reconcile_invoices(invoices, bank_txns, tolerance=5.00)
print(f"Match rate: {result['match_rate']:.0%}")
# Match rate: 100% (ACME matches exactly, TechFlow within $2 tolerance)

import csv
from pathlib import Path

def export_to_csv(categorized_invoices: list[dict],
                  output_path: str = "processed_invoices.csv"):
    """
    Export categorized invoice data to CSV for accounting system import.
    """
    rows = []
    for invoice in categorized_invoices:
        for item in invoice["line_items"]:
            rows.append({
                "invoice_number": invoice["invoice_number"],
                "vendor_name": invoice["vendor_name"],
                "invoice_date": invoice["invoice_date"],
                "due_date": invoice.get("due_date", ""),
                "line_description": item["description"],
                "quantity": item["quantity"],
                "unit_price": item["unit_price"],
                "line_amount": item["amount"],
                "gl_account": item["gl_account"],
                "subtotal": invoice["subtotal"],
                "tax": invoice["tax"],
                "total": invoice["total"],
                "currency": invoice.get("currency", "USD"),
            })

    with open(output_path, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
        writer.writeheader()
        writer.writerows(rows)

    print(f"Exported {len(rows)} line items to {output_path}")

import xmlrpc.client

def push_to_odoo(invoice_data: dict, odoo_url: str,
                 db: str, uid: int, password: str):
    """Push a processed invoice to Odoo via XML-RPC."""
    models = xmlrpc.client.ServerProxy(f"{odoo_url}/xmlrpc/2/object")

    # Create the vendor bill
    bill_id = models.execute_kw(
        db, uid, password,
        "account.move", "create",
        [{
            "move_type": "in_invoice",
            "partner_id": invoice_data["odoo_partner_id"],
            "invoice_date": invoice_data["invoice_date"],
            "ref": invoice_data["invoice_number"],
            "invoice_line_ids": [
                (0, 0, {
                    "name": item["description"],
                    "price_unit": item["unit_price"],
                    "quantity": item["quantity"],
                    "account_id": item["odoo_account_id"],
                })
                for item in invoice_data["line_items"]
            ],
        }]
    )
    return bill_id

def validate_extraction(data: dict) -> dict:
    """
    Validate extracted invoice data and flag issues.
    Returns data with a 'confidence' score and 'issues' list.
    """
    issues = []

    required_fields = ["vendor_name", "invoice_number", "invoice_date",
                       "total"]
    for field in required_fields:
        if not data.get(field):
            issues.append(f"Missing required field: {field}")

    # Check line item math
    if data.get("line_items") and data.get("subtotal"):
        line_sum = sum(
            item.get("amount", 0) for item in data["line_items"]
        )
        if abs(line_sum - data["subtotal"]) > 1.00:
            issues.append(
                f"Line items sum ({line_sum}) ≠ subtotal ({data['subtotal']})"
            )

    # Check tax math
    if data.get("subtotal") and data.get("tax") and data.get("total"):
        expected_total = data["subtotal"] + data["tax"]
        if abs(expected_total - data["total"]) > 1.00:
            issues.append(
                f"Subtotal + tax ({expected_total}) ≠ total ({data['total']})"
            )

    confidence = 1.0 - (len(issues) * 0.15)
    return {
        **data,
        "confidence": max(confidence, 0),
        "issues": issues,
        "needs_review": len(issues) > 0
    }