湖北航信发票信息提取

def detect_environment():
    """检测当前 Python 环境中有哪些库可用"""
    env = {"tier1_available": True, "tier2_available": False, "has_requests": False}

    # 检测 Tier 2 扩展库（PDF 解析需要）
    try:
        import fitz  # PyMuPDF
        env["tier2_available"] = True
    except ImportError:
        pass

    # 检测 requests 库（云端调用更方便）
    try:
        import requests
        env["has_requests"] = True
    except ImportError:
        pass

    return env

import os
import re
import json
import base64
import zipfile
import xml.etree.ElementTree as ET
from io import BytesIO
from datetime import datetime


# =====================================================
# 环境检测
# =====================================================

def detect_environment():
    """检测当前 Python 环境中有哪些库可用"""
    env = {"tier2_available": False, "has_requests": False}
    try:
        import fitz
        env["tier2_available"] = True
    except ImportError:
        pass
    try:
        import requests
        env["has_requests"] = True
    except ImportError:
        pass
    return env


# =====================================================
# 主入口
# =====================================================

def process_invoice(file_path, api_key=None, output_dir="."):
    """
    智能发票提取入口：自动检测环境，选择最优提取模式。
    输出 JSON + Excel + 报告。
    """
    env = detect_environment()
    ext = os.path.splitext(file_path)[1].lower()

    # 决定提取模式和解析方法
    if ext in (".xml", ".ofd"):
        # XML/OFD 始终可以本地解析（Tier 1，纯标准库）
        mode = "local"
        if ext == ".xml":
            result = parse_xml_invoice(file_path)
        else:
            result = parse_ofd_invoice(file_path)
    elif ext == ".zip":
        mode = "local"
        result = parse_zip_invoice(file_path)
    elif ext == ".pdf" and env["tier2_available"]:
        # PDF 需第三方库 PyMuPDF；JPG/PNG/BMP 图片格式不在支持范围
        mode = "local"
        result = parse_pdf_invoice(file_path)
    elif ext in (".jpg", ".jpeg", ".png", ".bmp"):
        # 图片格式已从本技能移除（v1.0.5），不再本地/云端支持
        return {"success": False,
                "error": f"不支持 {ext} 图片格式，支持格式：XML/OFD/PDF/ZIP"}
    else:
        # 仅标准库环境：PDF/扫描件等走云端提取
        mode = "cloud"
        # 云端调用前强制敏感内容审查（仅此路径触发；本地提取不上传、不审查）
        ok, reason = cloud_sensitive_review(file_path)
        if not ok:
            return {"success": False,
                    "error": f"云端调用被拒绝——敏感内容审查未通过: {reason}"}
        if not api_key:
            return {"success": False, "error": "云端提取模式需要提供 API Key"}
        result = extract_invoice_cloud(file_path, api_key)

    if not result.get("success"):
        return result

    # 生成输出文件
    base_name = os.path.splitext(os.path.basename(file_path))[0]
    os.makedirs(output_dir, exist_ok=True)

    # 输出 JSON
    json_path = os.path.join(output_dir, f"{base_name}_invoice.json")
    with open(json_path, "w", encoding="utf-8") as f:
        json.dump(result, f, ensure_ascii=False, indent=2)

    # 输出 Excel
    excel_path = os.path.join(output_dir, f"{base_name}_invoice.xlsx")
    generate_excel(result, excel_path)

    # 输出结果报告
    report_path = generate_report(result, file_path, mode, output_dir)

    return {
        "success": True,
        "mode": mode,
        "files": {"json": json_path, "excel": excel_path, "report": report_path},
        "invoice": result.get("invoice"),
    }


# =====================================================
# 云端调用前敏感内容审查（仅云端路径触发；本地提取不触发、不上传）
# =====================================================

# 敏感标识词表：命中任一即拒绝云端上传
SENSITIVE_MARKERS = ("绝密", "机密", "秘密", "涉密", "内部资料",
                     "国家秘密", "商业秘密", "内部文件")


def cloud_sensitive_review(file_path):
    """云端 API 调用前的敏感内容审查。返回 (ok, reason)。
    审查范围：文件名 + 文件头部 64KB 可读文本（XML/文本类可全文匹配；
    二进制 PDF/OFD 审查文件名）。本地提取路径不调用本函数。"""
    try:
        with open(file_path, "rb") as f:
            head = f.read(65536)
        name = os.path.basename(file_path)
        for kw in SENSITIVE_MARKERS:
            if kw.lower() in name.lower():
                return False, f"文件名含敏感标识'{kw}'"
        text = None
        for enc in ("utf-8", "gbk"):
            try:
                text = head.decode(enc)
                break
            except UnicodeDecodeError:
                continue
        if text:
            for kw in SENSITIVE_MARKERS:
                if kw in text:
                    return False, f"文件内容含敏感标识'{kw}'"
        return True, ""
    except Exception as e:
        return False, f"审查过程异常: {e}"


# =====================================================
# 云端提取（仅标准库，使用 urllib）
# =====================================================

def extract_invoice_cloud(file_path, api_key):
    """通过 HTTPS API 调用云端发票提取服务（仅使用 Python 标准库）"""
    import urllib.request

    with open(file_path, "rb") as f:
        file_b64 = base64.b64encode(f.read()).decode()

    payload = json.dumps({
        "name": "invoice-ai",
        "arguments": {
            "file_base64": file_b64,
            "file_name": os.path.basename(file_path),
        }
    }).encode("utf-8")

    req = urllib.request.Request(
        "https://skillhub.hbhtxx.com/v1/tools/call",
        data=payload,
        headers={
            "Content-Type": "application/json",
            "X-API-Key": api_key,
        },
        method="POST",
    )

    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read().decode("utf-8"))


# =====================================================
# Tier 1: XML 电子发票解析（纯标准库）
# =====================================================

def parse_xml_invoice(file_path):
    """解析 XML 电子发票，纯 Python 标准库，零依赖"""
    with open(file_path, "rb") as f:
        file_bytes = f.read()
    filename = os.path.basename(file_path)

    # 解码 XML
    try:
        xml_str = file_bytes.decode("utf-8")
    except UnicodeDecodeError:
        try:
            xml_str = file_bytes.decode("gbk")
        except Exception:
            return {"success": False, "error": "XML 编码解析失败"}

    try:
        root = ET.fromstring(xml_str)
    except ET.ParseError as e:
        return {"success": False, "error": f"XML 格式解析失败: {e}"}

    # 去除所有命名空间前缀
    def _strip_ns(el):
        if "}" in el.tag:
            el.tag = el.tag.split("}", 1)[1]
        for child in el:
            _strip_ns(child)

    _strip_ns(root)

    def _text(tag):
        """在整棵树中搜索标签文本"""
        for el in root.iter():
            if el.tag == tag and el.text:
                return el.text.strip()
        return ""

    def _child(parent, tag):
        """从指定父元素下查找子元素文本"""
        if parent is None:
            return ""
        for el in parent.iter():
            if el.tag == tag and el.text:
                return el.text.strip()
        return ""

    # 提取发票种类
    invoice_type = ""
    ei_type_el = root.find(".//EInvoiceType")
    vat_el = root.find(".//GeneralOrSpecialVAT")
    ei_label = _child(ei_type_el, "LabelName")
    vat_label = _child(vat_el, "LabelName")
    if ei_label and vat_label:
        invoice_type = f"{ei_label}({vat_label})"
    elif ei_label:
        invoice_type = ei_label
    elif vat_label:
        invoice_type = vat_label

    # 是否蓝字发票标志
    blue_flag = ""
    in_issu_el = root.find(".//InIssuType")
    if in_issu_el is not None:
        ln = _child(in_issu_el, "LabelName")
        lc = _child(in_issu_el, "LabelCode")
        if ln and lc:
            blue_flag = f"{ln}:{lc}"

    # 税率格式化：数电 XML 明细行 TaxRate 为小数（0.01），格式化为百分比
    def _fmt_tax_rate(rate):
        """税率格式化为百分比字符串：0.01->1%、0.13->13%、0->免税；已含 % 的旧版式 XML 原样保留"""
        if rate in ("", None):
            return ""
        try:
            v = float(str(rate).replace("%", ""))
        except ValueError:
            return rate
        if v == 0:
            return "免税"
        return f"{v * 100:g}%"

    # 提取商品明细
    items = []
    for item_el in root.findall(".//IssuItemInformation"):
        item_name = _child(item_el, "ItemName")
        if item_name:
            items.append({
                "商品名称": item_name,
                "项目名称": item_name,
                "规格型号": _child(item_el, "ItemSpecification"),
                "单位": _child(item_el, "ItemUnit"),
                "数量": _child(item_el, "ItemQuantity"),
                "单价": _child(item_el, "ItemPrice"),
                "金额": _child(item_el, "Amount"),
                "税率": _fmt_tax_rate(_child(item_el, "TaxRate")),
                "税额": _child(item_el, "ComTaxAm"),
                "价税合计": _child(item_el, "TotaltaxIncludedAmount"),
                "商品分类编码": _child(item_el, "TaxClassificationCode"),
            })

    # 备注：两处来源拼接
    specific_info = _text("SpecificInformation")
    remarks_info = _text("Remarks")
    remark = ""
    if specific_info and remarks_info:
        remark = f"{specific_info}n{remarks_info}"
    elif specific_info:
        remark = specific_info
    elif remarks_info:
        remark = remarks_info

    invoice = {
        "发票代码": _text("InvoiceCode"),
        "发票号码": _text("InvoiceNumber"),
        "开票日期": _text("IssueTime"),
        "价税合计": _text("TotalTax-includedAmount"),
        "价税合计大写": _text("TotalTax-includedAmountInChinese"),
        "不含税金额": _text("TotalAmWithoutTax"),
        "税额": _text("TotalTaxAm"),
        "销方名称": _text("SellerName"),
        "销方税号": _text("SellerIdNum"),
        "销方地址": _text("SellerAddr") or _text("SellerAddrTel"),
        "销方电话": _text("SellerTelNum"),
        "销方开户银行": _text("SellerBankName"),
        "销方开户行账号": _text("SellerBankAccNum"),
        "购方名称": _text("BuyerName"),
        "购方税号": _text("BuyerIdNum"),
        "购方地址": _text("BuyerAddr") or _text("BuyerAddrTel"),
        "购方电话": _text("BuyerTelNum"),
        "购方开户银行": _text("BuyerBankName"),
        "购方开户行账号": _text("BuyerBankAccNum"),
        "开票人": _text("Drawer"),
        "收款人": _text("Payee"),
        "复核人": _text("Reviewer"),
        "备注": remark,
        "附加信息": _text("AdditionalInformation"),
        "请求时间": _text("RequestTime"),
        "是否蓝字发票标志": blue_flag,
        "发票种类": invoice_type,
        "特定业务": _text("SpecialBusiness"),
        "税务机关代码": _text("TaxBureauCode"),
        "税务机关名称": _text("TaxBureauName"),
        "商品明细": items,
        "original_name": filename,
        "parse_tier": 1,
        "parse_method": "xml_stdlib",
    }

    return {"success": True, "invoice": invoice}


# =====================================================
# Tier 1: OFD 电子发票解析（纯标准库）
# =====================================================

def parse_ofd_invoice(file_path):
    """解析 OFD 电子发票（OFD 本质是 ZIP 包，内含 XML）"""
    filename = os.path.basename(file_path)

    try:
        with zipfile.ZipFile(file_path, "r") as zf:
            for name in zf.namelist():
                if "original_invoice" in name.lower() and name.endswith(".xml"):
                    xml_bytes = zf.read(name)
                    # 写入临时文件，复用 XML 解析器
                    tmp_path = file_path + ".tmp.xml"
                    with open(tmp_path, "wb") as f:
                        f.write(xml_bytes)
                    result = parse_xml_invoice(tmp_path)
                    os.remove(tmp_path)
                    if result.get("success") and result.get("invoice"):
                        result["invoice"]["parse_method"] = "ofd_unzip"
                        result["invoice"]["original_name"] = filename
                    return result
            return {"success": False, "error": "OFD 文件中未找到发票 XML"}
    except zipfile.BadZipFile:
        return {"success": False, "error": "OFD 文件格式无效，无法解压"}


# =====================================================
# Tier 2: PDF 电子发票解析（需要 PyMuPDF）
# =====================================================

def parse_pdf_invoice(file_path):
    """解析 PDF 电子发票，需要 PyMuPDF (fitz)"""
    try:
        import fitz
    except ImportError:
        return {
            "success": False,
            "error": "PDF 解析需要 PyMuPDF，请执行: pip install PyMuPDF",
            "setup_required": True,
        }

    filename = os.path.basename(file_path)

    try:
        with open(file_path, "rb") as f:
            file_bytes = f.read()
        doc = fitz.open(stream=file_bytes, filetype="pdf")
        full_text = ""
        for page in doc:
            full_text += page.get_text()
        doc.close()
    except Exception as e:
        return {"success": False, "error": f"PDF 解析失败: {e}"}

    if not full_text.strip():
        return {"success": False, "error": "PDF 中未提取到文本，可能为扫描件，请改用 XML/OFD 原始数据或调用云端 API 兜底"}

    return _extract_from_text(full_text, filename, "pdf_text")


# =====================================================
# 文本正则提取（PDF 文本提取用）
# =====================================================

def _extract_from_text(text, filename, method):
    """从文本中通过正则表达式提取发票关键字段"""
    def _find(pattern, text):
        m = re.search(pattern, text)
        return m.group(1).strip() if m else ""

    invoice = {
        "发票代码": _find(r"发票代码[：:s]*(d{10,12})", text),
        "发票号码": _find(r"发票号码[：:s]*(d{8})", text),
        "开票日期": _find(r"开票日期[：:s]*(d{4}年d{1,2}月d{1,2}日)", text),
        "价税合计": _find(r"价税合计[（(]小写[)）][：:s]*[¥￥]?([d.]+)", text),
        "价税合计大写": _find(r"价税合计[（(]大写[)）][：:s]*(.+)", text),
        "不含税金额": _find(r"不含税金额[：:s]*[¥￥]?([d.]+)", text),
        "税额": _find(r"税额[：:s]*[¥￥]?([d.]+)", text),
        "销方名称": _find(r"销[售货]方.*?名[称][：:s]*(.+)", text),
        "销方税号": _find(r"销[售货]方.*?纳税人识别号[：:s]*(S+)", text),
        "销方地址": "",
        "销方电话": "",
        "销方开户银行": "",
        "销方开户行账号": "",
        "购方名称": _find(r"购[买货]方.*?名[称][：:s]*(.+)", text),
        "购方税号": _find(r"购[买货]方.*?纳税人识别号[：:s]*(S+)", text),
        "购方地址": "",
        "购方电话": "",
        "购方开户银行": "",
        "购方开户行账号": "",
        "开票人": _find(r"开票人[：:s]*(.+)", text),
        "收款人": _find(r"收款人[：:s]*(.+)", text),
        "复核人": _find(r"复核人[：:s]*(.+)", text),
        "备注": _find(r"备注[：:s]*(.+)", text),
        "附加信息": "",
        "请求时间": "",
        "是否蓝字发票标志": "",
        "发票种类": "",
        "特定业务": "",
        "税务机关代码": "",
        "税务机关名称": "",
        "商品明细": [],
        "original_name": filename,
        "parse_tier": 2,
        "parse_method": method,
    }

    return {"success": True, "invoice": invoice}


# =====================================================
# ZIP 批量处理
# =====================================================

def parse_zip_invoice(file_path):
    """解压 ZIP 并递归处理其中的发票文件"""
    results = []
    with zipfile.ZipFile(file_path, "r") as zf:
        for name in zf.namelist():
            if name.endswith("/"):
                continue
            ext = os.path.splitext(name)[1].lower()
            if ext not in (".xml", ".ofd", ".pdf"):
                continue
            content = zf.read(name)
            tmp_path = os.path.join(os.path.dirname(file_path) or ".", f"_tmp_{os.path.basename(name)}")
            with open(tmp_path, "wb") as f:
                f.write(content)
            try:
                if ext in (".xml",):
                    r = parse_xml_invoice(tmp_path)
                elif ext == ".ofd":
                    r = parse_ofd_invoice(tmp_path)
                elif ext == ".pdf":
                    r = parse_pdf_invoice(tmp_path)
                else:
                    continue                     # 图片/其他格式不在支持范围
                results.append(r)
            finally:
                if os.path.exists(tmp_path):
                    os.remove(tmp_path)
    return {"success": True, "count": len(results), "invoices": results}


# =====================================================
# 输出：Excel 报表
# =====================================================

def generate_excel(invoice_data, output_path):
    """生成发票信息 Excel 报表"""
    try:
        import openpyxl
    except ImportError:
        # 回退到 CSV
        _generate_csv(invoice_data, output_path.replace(".xlsx", ".csv"))
        return

    inv = invoice_data.get("invoice", {})
    wb = openpyxl.Workbook()

    # Sheet 1: 发票主信息
    ws1 = wb.active
    ws1.title = "发票主信息"
    main_fields = [
        ("发票代码", "发票代码"),
        ("发票号码", "发票号码"),
        ("开票日期", "开票日期"),
        ("发票种类", "发票种类"),
        ("是否蓝字发票标志", "是否蓝字发票标志"),
        ("价税合计", "价税合计"),
        ("价税合计大写", "价税合计大写"),
        ("不含税金额", "不含税金额"),
        ("税额", "税额"),
        ("销方名称", "销方名称"),
        ("销方税号", "销方税号"),
        ("销方地址", "销方地址"),
        ("销方电话", "销方电话"),
        ("销方开户银行", "销方开户银行"),
        ("销方开户行账号", "销方开户行账号"),
        ("购方名称", "购方名称"),
        ("购方税号", "购方税号"),
        ("购方地址", "购方地址"),
        ("购方电话", "购方电话"),
        ("购方开户银行", "购方开户银行"),
        ("购方开户行账号", "购方开户行账号"),
        ("开票人", "开票人"),
        ("收款人", "收款人"),
        ("复核人", "复核人"),
        ("备注", "备注"),
        ("解析层级", "parse_tier"),
        ("解析方法", "parse_method"),
    ]
    ws1.append([label for label, _ in main_fields])
    row = []
    for _, key in main_fields:
        val = inv.get(key, "")
        if isinstance(val, (int, float)):
            row.append(val)
        else:
            row.append(str(val) if val else "")
    ws1.append(row)

    # Sheet 2: 商品明细
    ws2 = wb.create_sheet("商品明细")
    item_headers = [
        "发票号码", "商品名称", "规格型号", "单位", "数量",
        "单价", "金额", "税率", "税额", "价税合计", "商品分类编码",
    ]
    ws2.append(item_headers)
    invoice_no = inv.get("发票号码", "")
    for item in inv.get("商品明细", []):
        ws2.append([
            invoice_no,
            item.get("商品名称", ""),
            item.get("规格型号", ""),
            item.get("单位", ""),
            item.get("数量", ""),
            item.get("单价", ""),
            item.get("金额", ""),
            item.get("税率", ""),
            item.get("税额", ""),
            item.get("价税合计", ""),
            item.get("商品分类编码", ""),
        ])

    wb.save(output_path)


def _generate_csv(invoice_data, output_path):
    """回退方案：生成 CSV 文件（仅标准库）"""
    import csv

    inv = invoice_data.get("invoice", {})
    with open(output_path, "w", newline="", encoding="utf-8-sig") as f:
        writer = csv.writer(f)
        headers = [
            "发票代码", "发票号码", "开票日期", "发票种类", "价税合计",
            "不含税金额", "税额", "销方名称", "销方税号", "购方名称", "购方税号",
            "开票人", "备注", "解析方法",
        ]
        writer.writerow(headers)
        writer.writerow([inv.get(h, "") for h in headers])


# =====================================================
# 输出：结果报告
# =====================================================

def generate_report(invoice_data, file_path, mode, output_dir=".", suffix=""):
    """生成 Markdown 格式的发票提取结果报告（suffix 用于多票批量区分文件名，如 _1/_2）"""
    inv = invoice_data.get("invoice", {})
    base_name = os.path.splitext(os.path.basename(file_path))[0]

    # 公众号二维码：由 HTTP 二维码接口动态生成（扫码关注"湖北航天信息"）
    qr_url = _wechat_qr_url()

    lines = [
        "# 发票信息提取报告",
        "",
        f"**提取时间**：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
        f"**源文件**：{os.path.basename(file_path)}",
        f"**提取模式**：{'云端提取' if mode == 'cloud' else '本地提取'}",
        f"**解析层级**：Tier {inv.get('parse_tier', '-')}",
        f"**解析方法**：{inv.get('parse_method', '-')}",
        "",
    ]

    # === 公众号二维码（在发票解析信息之前展示，HTTP 接口动态生成） ===
    if qr_url:
        lines.extend([
            '<div align="center">',
            "",
            f"![扫码关注"湖北航天信息"公众号]({qr_url})",
            "",
            "**扫码关注"湖北航天信息"**",
            "",
            "</div>",
            "",
        ])

    # === 财智存 · 数电票发票管理（与二维码一同置于发票解析信息之前） ===
    lines.extend([
        "---",
        "",
        "## 📢 告别数电发票管理烦恼！ 📢",
        "",
        "还在为发票重复入账、按月归类头疼？",
        "员工报销总怕重复？打印发票不能批量操作？",
        "",
        "✨ 发票归档-财智存·数电票发票管理 来帮你！",
        "",
        "- ✅ 一键下载 进项/销项发票（PDF/XML）",
        "- ✅ 自动归类 按年/月整理，查找超方便",
        "- ✅ 报销状态标记 避免重复报销",
        "- ✅ 批量打印 灵活设置，一张A4打多张票，省纸省时！",
        "",
    ])

    lines.extend([
        "## 发票主信息",
        "",
        "| 字段 | 值 |",
        "|------|----|",
        f"| 发票代码 | {inv.get('发票代码', '-')} |",
        f"| 发票号码 | {inv.get('发票号码', '-')} |",
        f"| 开票日期 | {inv.get('开票日期', '-')} |",
        f"| 发票种类 | {inv.get('发票种类', '-')} |",
        f"| 是否蓝字发票 | {inv.get('是否蓝字发票标志', '-')} |",
        f"| 价税合计 | {inv.get('价税合计', '-')} 元 |",
        f"| 价税合计(大写) | {inv.get('价税合计大写', '-')} |",
        f"| 不含税金额 | {inv.get('不含税金额', '-')} 元 |",
        f"| 税额 | {inv.get('税额', '-')} 元 |",
        f"| 销方名称 | {inv.get('销方名称', '-')} |",
        f"| 销方税号 | {inv.get('销方税号', '-')} |",
        f"| 销方地址 | {inv.get('销方地址', '-')} |",
        f"| 销方电话 | {inv.get('销方电话', '-')} |",
        f"| 销方开户银行 | {inv.get('销方开户银行', '-')} |",
        f"| 销方开户行账号 | {inv.get('销方开户行账号', '-')} |",
        f"| 购方名称 | {inv.get('购方名称', '-')} |",
        f"| 购方税号 | {inv.get('购方税号', '-')} |",
        f"| 购方地址 | {inv.get('购方地址', '-')} |",
        f"| 购方电话 | {inv.get('购方电话', '-')} |",
        f"| 购方开户银行 | {inv.get('购方开户银行', '-')} |",
        f"| 购方开户行账号 | {inv.get('购方开户行账号', '-')} |",
        f"| 开票人 | {inv.get('开票人', '-')} |",
        f"| 收款人 | {inv.get('收款人', '-')} |",
        f"| 复核人 | {inv.get('复核人', '-')} |",
        f"| 备注 | {inv.get('备注', '-')} |",
        "",
    ])

    items = inv.get("商品明细", [])
    if items:
        lines.append("## 商品明细")
        lines.append("")
        lines.append("| 商品名称 | 规格型号 | 单位 | 数量 | 单价 | 金额 | 税率 | 税额 | 价税合计 |")
        lines.append("|----------|----------|------|------|------|------|------|------|----------|")
        for item in items:
            lines.append(
                f"| {item.get('商品名称', '-')} "
                f"| {item.get('规格型号', '-')} "
                f"| {item.get('单位', '-')} "
                f"| {item.get('数量', '-')} "
                f"| {item.get('单价', '-')} "
                f"| {item.get('金额', '-')} "
                f"| {item.get('税率', '-')} "
                f"| {item.get('税额', '-')} "
                f"| {item.get('价税合计', '-')} |"
            )

    report_path = os.path.join(
        output_dir, f"invoice_report_{base_name}{suffix}.md"
    )
    with open(report_path, "w", encoding="utf-8") as f:
        f.write("n".join(lines))

    return report_path


# =====================================================
# 公众号二维码：HTTP 接口动态生成（无需本地 qrcode/pillow 依赖）
# 报告/汇总报告中的二维码 Markdown 图片直接引用 _wechat_qr_url()
# 返回的图片 URL，不生成 invoice_qrcode_*.png 本地文件。
# =====================================================
WECHAT_MP_URL = "http://weixin.qq.com/r/mp/DEMXD4PE9t6Jrcds9xYe"  # 公众号链接（扫码跳转目标）
# HTTP 二维码生成接口模板；{url} 由 _wechat_qr_url() URL 编码后填充。
# 如需切换其他二维码服务，仅修改 QR_API_URL 常量即可（如 data={url}&size=240x240）。
QR_API_URL = ("https://api.qrserver.com/v1/create-qr-code/"
              "?size=240x240&margin=10&data={url}")


def _wechat_qr_url():
    """“湖北航天信息”公众号二维码图片 URL：由 HTTP 二维码接口按公众号链接动态生成。
    返回形如 https://api.qrserver.com/v1/create-qr-code/?...&data=<url编码后的公众号链接>。"""
    from urllib.parse import quote
    return QR_API_URL.format(url=quote(WECHAT_MP_URL, safe=""))

# =====================================================
# OFD / ZIP 纯版式包解析（Layout-Text 变通路径，Tier 1 纯标准库）
# 触发：.ofd/.zip 内无 original_invoice.xml，但含 Doc_0/Pages/Page_0/Content.xml
# =====================================================
import os
import re
import zipfile
import xml.etree.ElementTree as ET

OFD_NS = "{http://www.ofdspec.org/2016}"

# 列边界修正常量：依据“金额/税率/单价”数字右对齐特征标定；换版式出现串列时调整
COL_BOUNDARY_OVERRIDE = {
    "单价": 137.0,   # 单价列右界：容纳长数字（如 30.188679245283）
    "金额": 166.0,   # 金额列右界：负数金额(如 -30.19)与税率(6%)同为右对齐，须分隔
}
HEADER_CANDIDATES = {  # 明细表表头文本(去空白后) → 标准列名
    "项目名称": "项目名称", "商品名称": "项目名称", "规格型号": "规格型号",
    "单位": "单位", "数量": "数量", "单价": "单价", "金额": "金额",
    "税率/征收率": "税率", "税率": "税率", "征收率": "税率", "税额": "税额",
}


def _extract_ofd_text_objects(content_xml_text):
    """提取版式文本对象：text + (x, y, size)。
    TextCode 数据以真实 CDATA 区段存于文本节点，ElementTree 自动还原为纯文本。"""
    root = ET.fromstring(content_xml_text)
    objs = []
    for to in root.iter(OFD_NS + "TextObject"):
        attr = to.attrib
        b = [float(v) for v in attr.get("Boundary", "0 0 0 0").split()[:4]]
        size = float(attr.get("Size", "0"))
        buf = [tc.text for tc in to.iter(OFD_NS + "TextCode") if tc.text]
        txt = re.sub(r"s+", "", "".join(buf))
        if txt:
            objs.append({"x": b[0], "y": b[1], "size": size, "text": txt})
    return objs


def _row_text_right(objs, label, x_lo=0.0, x_hi=1e9):
    """与 label 同行(y 差<0.5)且在 label 右侧(x 更大)的最近数据文本。"""
    for o in objs:
        if o["text"] == label and x_lo <= o["x"] < x_hi:
            right = sorted((p for p in objs
                            if abs(p["y"] - o["y"]) < 0.5 and p["x"] > o["x"]
                            and p["text"] != label),
                           key=lambda p: p["x"])
            if right:
                return right[0]["text"]
    return ""


def _party_info(objs):
    """购销方：同 y 并列两套标签簇（购方 x 较小 / 销方 x 较大），簇内 标签→右侧数据。"""
    labels = ["名称:", "统一社会信用代码/纳税人识别号：", "地址电话：", "开户行及账号："]
    pos = {lb: sorted({o["x"] for o in objs if o["text"] == lb}) for lb in labels}
    if len(pos.get("名称:", [])) < 2:
        return {}, {}
    sep = (pos["名称:"][0] + pos["名称:"][1]) / 2.0  # 购/销两簇分隔点

    def cluster(x_lo, x_hi, name_key, tax_key):
        info = {}
        for o in objs:
            if not (x_lo <= o["x"] < x_hi):
                continue
            if o["text"] == "名称:":
                v = _row_text_right(objs, "名称:", x_lo, x_hi)
                if v:
                    info[name_key] = v
            elif o["text"] == "统一社会信用代码/纳税人识别号：":
                v = _row_text_right(objs, "统一社会信用代码/纳税人识别号：", x_lo, x_hi)
                if v:
                    info[tax_key] = v
            elif o["text"] in ("地址电话：", "开户行及账号：") and o["text"] not in info:
                v = _row_text_right(objs, o["text"], x_lo, x_hi)
                if v:
                    info[o["text"]] = v
        return info

    buyer = cluster(-1e9, sep, "购方名称", "购方税号")
    seller = cluster(sep, 1e9, "销方名称", "销方税号")
    return buyer, seller


def _item_rows(objs, header_y):
    """明细行：表头行之下至合计行之上，按 y 分桶 → 列名 → 文本。"""
    from collections import defaultdict

    hdr = {}  # 标准列名 -> 表头 x
    for o in objs:
        if abs(o["y"] - header_y) < 0.5 and o["text"] in HEADER_CANDIDATES:
            hdr.setdefault(HEADER_CANDIDATES[o["text"]], o["x"])
    cols = sorted(hdr.items(), key=lambda kv: kv[1])
    bounds = []
    for i, (name, x0) in enumerate(cols):
        right = cols[i + 1][1] if i + 1 < len(cols) else 1e9
        bound = (x0 + right) / 2.0 if i + 1 < len(cols) else 1e9
        if name in COL_BOUNDARY_OVERRIDE:
            bound = COL_BOUNDARY_OVERRIDE[name]
        bounds.append([name, bound])

    def col_of(x):
        for name, b in bounds:
            if x < b:
                return name
        return cols[0][0] if cols else "项目名称"

    total_y = None
    for o in objs:
        if o["text"].endswith("合计") and o["x"] < 60 and o["y"] > header_y:
            total_y = o["y"] if total_y is None else min(total_y, o["y"])
    bottom = total_y if total_y is not None else min(
        (o["y"] for o in objs if "价税合计" in o["text"]), default=1e9)

    buckets = defaultdict(list)
    for o in objs:
        if header_y + 0.5 < o["y"] < bottom - 0.5:
            buckets[round(o["y"], 1)].append(o)
    rows = []
    for y in sorted(buckets):
        row = {}
        for o in buckets[y]:
            if o["text"] in HEADER_CANDIDATES or o["text"] in (
                    "名称:", "统一社会信用代码/纳税人识别号：", "地址电话：", "开户行及账号：",
                    "购", "买", "销", "售", "方", "信", "息", "备", "注", "备注"):
                continue
            row.setdefault(col_of(o["x"]), o["text"])
        if "项目名称" in row:
            rows.append(row)
    # 跨行名称拼接：仅含名称、无数字列的行并入上一行
    merged = []
    num_cols = {"规格型号", "单位", "数量", "单价", "金额", "税率", "税额", "价税合计"}
    for r in rows:
        if merged and all(not r.get(c) for c in num_cols):
            merged[-1]["项目名称"] += r["项目名称"]
        else:
            merged.append(dict(r))
    return merged


def extract_ofd_layout_invoice(file_path):
    """OFD / 新版式 ZIP 纯版式包提取入口（无 original_invoice.xml 时调用）。"""
    filename = os.path.basename(file_path)
    try:
        with zipfile.ZipFile(file_path) as zf:
            cand = [n for n in zf.namelist()
                    if n.lower().endswith("content.xml") and "/pages/" in n.lower()]
            if not cand:
                return {"success": False, "error": "未找到版式文件 Pages/.../Content.xml"}
            content_xml = zf.read(sorted(cand, key=len)[0])  # 多页取第一页
    except zipfile.BadZipFile:
        return {"success": False, "error": "文件非有效 OFD/ZIP 包"}

    objs = _extract_ofd_text_objects(content_xml)

    # ---- 抬头 ----
    title = max((o for o in objs if "电子发票" in o["text"] or "增值税" in o["text"]),
                key=lambda o: o["size"], default=None)
    invoice_type = title["text"] if title else ""
    invoice_no = _row_text_right(objs, "发票号码：")
    issue_date = _row_text_right(objs, "开票日期：")

    # ---- 购销方 ----
    buyer, seller = _party_info(objs)

    # ---- 明细表 ----
    header_y = None
    for o in objs:
        if o["text"] in ("项目名称", "商品名称") and "规格型号" in {
                p["text"] for p in objs if abs(p["y"] - o["y"]) < 0.5}:
            header_y = o["y"]
            break
    items_raw = _item_rows(objs, header_y) if header_y is not None else []
    items = [{
        "商品名称": it.get("项目名称", ""), "项目名称": it.get("项目名称", ""),
        "规格型号": it.get("规格型号", ""), "单位": it.get("单位", ""),
        "数量": it.get("数量", ""), "单价": it.get("单价", ""),
        "金额": it.get("金额", ""), "税率": it.get("税率", ""),
        "税额": it.get("税额", ""), "价税合计": it.get("价税合计", ""),
        "商品分类编码": it.get("商品分类编码", ""),
    } for it in items_raw]

    # ---- 合计 / 价税合计 ----
    total_am, total_tax = "", ""
    for o in objs:
        if o["text"] == "合计" and o["x"] < 60:
            same = sorted((p for p in objs if abs(p["y"] - o["y"]) < 0.5
                           and p["text"].startswith("¥")), key=lambda p: p["x"])
            if len(same) >= 2:
                total_am, total_tax = same[0]["text"], same[1]["text"]
            break
    amt_cn = next((o["text"] for o in objs
                   if any(k in o["text"] for k in ("圆", "元整", "整"))
                   and o["text"].startswith(("ⓧ", "(", "零", "壹", "贰", "叁", "肆",
                                             "伍", "陆", "柒", "捌", "玖", "拾"))), "")
    amt_small = ""
    for o in objs:
        if "小写" in o["text"]:
            amt_small = _row_text_right(objs, "（小写）")
            break
    if not amt_small:
        amt_small = next((o["text"] for o in objs if o["text"].startswith("¥")), "")

    # ---- 备注 / 开票人 ----
    remark = next((o["text"] for o in objs
                   if o["x"] > 8 and 104 < o["y"] < 129
                   and o["text"] not in ("备注", "备", "注")
                   and not o["text"].startswith("¥")), "")
    if not remark:
        v = _row_text_right(objs, "备注")
        remark = v or ""
    drawer = _row_text_right(objs, "开票人：") or _row_text_right(objs, "开 票 人：")

    blue_flag = ("红字发票(负数)"
                 if any(("负" in v) or ("红冲" in v) for v in (amt_cn, remark, total_am))
                 else "蓝字发票")

    invoice = {
        "发票代码": "", "发票号码": invoice_no, "开票日期": issue_date,
        "发票种类": invoice_type, "是否蓝字发票标志": blue_flag,
        "价税合计": amt_small.replace("¥", ""),
        "价税合计大写": amt_cn,
        "不含税金额": total_am.replace("¥", ""),
        "税额": total_tax.replace("¥", ""),
        "销方名称": seller.get("销方名称", ""), "销方税号": seller.get("销方税号", ""),
        "销方地址": (seller.get("地址电话：") or "").split(" ")[0],
        "销方电话": "", "销方开户银行": "", "销方开户行账号": "",
        "购方名称": buyer.get("购方名称", ""), "购方税号": buyer.get("购方税号", ""),
        "购方地址": "", "购方电话": "", "购方开户银行": "", "购方开户行账号": "",
        "开票人": drawer, "收款人": "", "复核人": "",
        "备注": remark, "附加信息": "", "请求时间": "", "特定业务": "",
        "税务机关代码": "", "税务机关名称": "",
        "商品明细": items,
        "original_name": filename,
        "parse_tier": 1,
        "parse_method": "ofd_layout_stdlib",
    }
    return {"success": True, "invoice": invoice}

def process_invoice(file_path, api_key=None, output_dir="."):
    """智能发票提取入口：自动检测环境与包类型，选择最优提取路径。"""
    env = detect_environment()
    ext = os.path.splitext(file_path)[1].lower()

    if ext in (".xml", ".ofd", ".zip"):
        mode = "local"
        if ext == ".xml":
            result = parse_xml_invoice(file_path)
        elif ext == ".ofd":
            result = parse_ofd_invoice(file_path)          # 传统 OFD（含 original_invoice.xml）
            if not (result.get("success") and result.get("invoice", {}).get("发票号码")):
                result = extract_ofd_layout_invoice(file_path)   # 新版式纯版式 OFD 兜底
        else:
            result = parse_zip_invoice_v2(file_path)       # 增强 ZIP：识别新版式 OFD 包
    elif ext == ".pdf" and env["tier2_available"]:
        mode = "local"
        try:
            result = parse_pdf_invoice_v4(file_path)   # A-4 坐标版（推荐，字段完整）
        except NameError:
            result = parse_pdf_invoice(file_path)      # 未追加 A-4 代码时回退正则版
    elif ext in (".jpg", ".jpeg", ".png", ".bmp"):
        # 图片格式已从本技能移除（v1.0.5），不再本地/云端支持
        return {"success": False,
                "error": f"不支持 {ext} 图片格式，支持格式：XML/OFD/PDF/ZIP"}
    else:
        mode = "cloud"
        # 云端调用前强制敏感内容审查（仅此路径触发；本地提取不上传、不审查）
        ok, reason = cloud_sensitive_review(file_path)
        if not ok:
            return {"success": False,
                    "error": f"云端调用被拒绝——敏感内容审查未通过: {reason}"}
        if not api_key:
            return {"success": False, "error": "云端提取模式需要提供 API Key"}
        result = extract_invoice_cloud(file_path, api_key)

    if not result.get("success"):
        return result
    # 统一处理批量结果（zip 多票时逐张输出）
    invoices = result.get("invoices") or [result]
    base_name = os.path.splitext(os.path.basename(file_path))[0]
    os.makedirs(output_dir, exist_ok=True)
    first = None
    for i, r in enumerate(invoices):
        if not r.get("invoice"):
            continue
        suffix = f"_{i + 1}" if len(invoices) > 1 else ""
        inv = r["invoice"]
        json_path = os.path.join(output_dir, f"{base_name}{suffix}_invoice.json")
        with open(json_path, "w", encoding="utf-8") as f:
            json.dump({"success": True, "invoice": inv}, f, ensure_ascii=False, indent=2)
        excel_path = os.path.join(output_dir, f"{base_name}{suffix}_invoice.xlsx")
        generate_excel({"invoice": inv}, excel_path)
        generate_report({"invoice": inv}, file_path, mode, output_dir, suffix=suffix)
        first = {"success": True, "mode": mode,
                 "files": {"json": json_path, "excel": excel_path,
                           "report": os.path.join(
                               output_dir, f"invoice_report_{os.path.splitext(os.path.basename(file_path))[0]}{suffix}.md")},
                 "invoice": inv}
    # 多票（>=2）时自动产出汇总报告（含公众号二维码 + 财智存介绍），作为交付物首项
    if len(invoices) > 1:
        summary_path = generate_summary_report(file_path, invoices, mode, output_dir)
        if first is not None:
            first["files"]["summary_report"] = summary_path
    return first or result


def parse_zip_invoice_v2(zip_path):
    """增强版 ZIP 处理（v1.0.4 修订）：
    ① 整体为新版式 OFD 包(含 OFD.xml + Pages/*/Content.xml) → extract_ofd_layout_invoice；
    ② 普通包逐文件：数电发票 XML（dzfp_*.xml / d111zfp_*.xml / einv_*.xml /
       original_invoice.xml 或根元素 <EInvoice>）→ parse_xml_invoice；
    ③ 其余版式/资源类 XML 不是发票本体，直接跳过；PDF 按扩展名解析（JPG/PNG/BMP 图片格式不在支持范围）。"""
    results = []
    with zipfile.ZipFile(zip_path) as zf:
        names = zf.namelist()
        is_ofd_pkg = any(n.lower().endswith("ofd.xml") for n in names) and any(
            "content.xml" in n.lower() and "/pages/" in n.lower() for n in names)
        if is_ofd_pkg:
            r = extract_ofd_layout_invoice(zip_path)
            if r.get("success"):
                return r
        for name in names:
            if name.endswith("/"):
                continue
            ext = os.path.splitext(name)[1].lower()
            if ext not in (".xml", ".ofd", ".pdf"):
                continue
            content = zf.read(name)
            tmp_path = os.path.join(os.path.dirname(zip_path) or ".",
                                    f"_tmp_{os.path.basename(name)}")
            with open(tmp_path, "wb") as f:
                f.write(content)
            try:
                low = name.lower()
                if ext == ".xml":
                    # 数电发票 XML 判定：文件名特征(original_invoice/dzfp_/d111zfp_/einv_/invoice)
                    # 或内容根为 <EInvoice>；其余版式/资源 XML 不是发票本体，跳过
                    is_einv = any(k in low for k in (
                        "original_invoice", "dzfp_", "d111zfp_", "einv_", "invoice")) 
                        or b"<EInvoice" in content[:500]
                    if not is_einv:
                        continue
                    r = parse_xml_invoice(tmp_path)            # 真实数电发票 XML
                elif ext == ".ofd":
                    r = parse_ofd_invoice(tmp_path)
                    if not (r.get("success") and r.get("invoice", {}).get("发票号码")):
                        r = extract_ofd_layout_invoice(tmp_path)
                elif ext == ".pdf":
                    r = parse_pdf_invoice(tmp_path)
                else:
                    continue                     # 图片/其他格式不在支持范围
                results.append(r)
            finally:
                if os.path.exists(tmp_path):
                    os.remove(tmp_path)
    return {"success": True, "count": len(results), "invoices": results}


def generate_summary_report(zip_path, invoices, mode, output_dir="."):
    """多票（>=2）zip 汇总报告生成器：头部元信息 + 公众号二维码区块 + 财智存介绍区块
    + 汇总统计 + 全部发票一览 + 商品明细一览。产出 invoice_summary_{包名}.md 并返回绝对路径。
    process_invoice 在检测到多票时自动调用本函数；汇总报告为交付物首项。"""
    base_name = os.path.splitext(os.path.basename(zip_path))[0]
    os.makedirs(output_dir, exist_ok=True)

    # 公众号二维码：由 HTTP 二维码接口动态生成（与逐票报告一致）
    qr_url = _wechat_qr_url()

    lines = [
        "# 发票批量提取汇总报告",
        "",
        f"**提取时间**：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
        f"**源文件**：{os.path.basename(zip_path)}（共 {len(invoices)} 张发票）",
        f"**提取模式**：{'云端提取' if mode == 'cloud' else '本地提取'}",
        "",
    ]

    # === 公众号二维码区块（在发票信息之前展示，HTTP 接口动态生成） ===
    if qr_url:
        lines.extend([
            '<div align="center">',
            "",
            f'![扫码关注"湖北航天信息"公众号]({qr_url})',
            "",
            '**扫码关注"湖北航天信息"**',
            "",
            "</div>",
            "",
            "---",
            "",
        ])

    # === 财智存 · 数电票发票管理介绍区块（与二维码同置于发票信息之前） ===
    lines.extend([
        "## 📢 告别数电发票管理烦恼！ 📢",
        "",
        "还在为发票重复入账、按月归类头疼？",
        "员工报销总怕重复？打印发票不能批量操作？",
        "",
        "✨ 发票归档-财智存·数电票发票管理 来帮你！",
        "",
        "- ✅ 一键下载 进项/销项发票（PDF/XML）",
        "- ✅ 自动归类 按年/月整理，查找超方便",
        "- ✅ 报销状态标记 避免重复报销",
        "- ✅ 批量打印 灵活设置，一张A4打多张票，省纸省时！",
        "",
    ])

    # === 汇总统计 ===
    def _num(v):
        try:
            return float(v)
        except (TypeError, ValueError):
            return 0.0

    total = sum(_num(r.get("invoice", {}).get("价税合计"))
                for r in invoices if r.get("invoice"))
    lines.extend([
        "## 汇总统计",
        "",
        "| 指标 | 值 |",
        "|------|----|",
        f"| 发票张数 | {len(invoices)} 张 |",
        f"| 价税合计累计 | {total:.2f} 元 |",
        "",
        "## 发票一览",
        "",
        "| # | 发票号码 | 开票日期 | 发票种类 | 购方名称 | 销方名称 | 价税合计 | 税额 | 蓝字/红字 |",
        "|---|----------|----------|----------|----------|----------|----------|------|-----------|",
    ])
    for i, r in enumerate(invoices, 1):
        inv = r.get("invoice") or {}
        flag = str(inv.get("是否蓝字发票标志", ""))
        kind = "红字" if "N" in flag else "蓝字"
        lines.append(
            f"| {i} | {inv.get('发票号码', '-')} | {inv.get('开票日期', '-')} "
            f"| {inv.get('发票种类', '-')} | {inv.get('购方名称', '-')} "
            f"| {inv.get('销方名称', '-')} | {inv.get('价税合计', '-')} "
            f"| {inv.get('税额', '-')} | {kind} |"
        )

    # === 商品明细一览 ===
    lines.extend([
        "",
        "## 商品明细一览",
        "",
        "| 发票号码 | 购方名称 | 商品名称 | 金额 | 税率 | 税额 | 价税合计 |",
        "|----------|----------|----------|------|------|------|----------|",
    ])
    for r in invoices:
        inv = r.get("invoice") or {}
        for it in inv.get("商品明细", []):
            lines.append(
                f"| {inv.get('发票号码', '-')} | {inv.get('购方名称', '-')} "
                f"| {it.get('商品名称', '-')} | {it.get('金额', '-')} "
                f"| {it.get('税率', '-')} | {it.get('税额', '-')} "
                f"| {it.get('价税合计', '-')} |"
            )
    lines.append("")

    report_path = os.path.join(output_dir, f"invoice_summary_{base_name}.md")
    with open(report_path, "w", encoding="utf-8") as f:
        f.write("n".join(lines))
    return report_path

import os
"""
依赖: pip install pymupdf
说明: 数电票 PDF 文字层是坐标散块(get_text() 阅读序乱)，含单字跨格排布(合/计、单/位)。
      本模块: words/spans 坐标 → 贪心行聚类(y 容差) → 行内按 x 排序聚合成"行对象"，
      再按标签定位 + 表头列边界归属重建结构化 invoice（与 OFD 版式路径同思路）。
"""
import re
from collections import defaultdict

try:
    import pymupdf
except ImportError:
    import fitz as pymupdf

TOL_Y = 4.0     # 行聚类 y 容差(pt)：普票税号行差 3.1pt 也需同行
GAP_X = 8.0     # 行内同词分段间距(pt)
HEADERS = {"项目名称": "项目名称", "商品名称": "项目名称", "规格型号": "规格型号",
           "单位": "单位", "数量": "数量", "单价": "单价", "金额": "金额",
           "税率/征收率": "税率", "税率": "税率", "征收率": "税率", "税额": "税额"}
# 数量列右界修正：数量数值(~286)与单价长数字(~297.4)间
COL_OVERRIDE = {"数量": 292.0}
# PDF 全角标点标签
LBL_NAME = "名称："
LBL_TAXID = "统一社会信用代码/纳税人识别号："
LBL_BANK = "开户行及账号："
LBL_ADDR = "地址电话："


def extract_rows(pdf_path):
    """PDF → 行对象列表。每行: {page, y, text(行内按x拼接去空白), segs:[{x,x1,size,text}]}"""
    doc = pymupdf.open(pdf_path)
    rows = []
    try:
        for pno in range(len(doc)):
            page = doc[pno]
            d = page.get_text("dict")
            # 收集该页所有文本段(合并同词 spans)
            segs_all = []
            for blk in d["blocks"]:
                if blk.get("type") != 0:
                    continue
                for line in blk["lines"]:
                    spans = sorted(line["spans"], key=lambda s: s["bbox"][0])
                    segs = []
                    for s in spans:
                        txt = "".join(s["text"].split())
                        if not txt:
                            continue
                        if segs and (s["bbox"][0] - segs[-1]["x1"]) < GAP_X:
                            segs[-1]["text"] += txt
                            segs[-1]["x1"] = s["bbox"][2]
                        else:
                            segs.append({"x": s["bbox"][0], "y": s["bbox"][1],
                                         "x1": s["bbox"][2], "size": s["size"], "text": txt})
                    segs_all.extend(segs)
            segs_all.sort(key=lambda s: (s["y"], s["x"]))
            # 贪心行聚类
            cur = None
            for s in segs_all:
                if cur is None or (s["y"] - cur["y"]) > TOL_Y:
                    if cur:
                        rows.append(cur)
                    cur = {"page": pno, "y": s["y"], "segs": [s]}
                else:
                    cur["segs"].append(s)
            if cur:
                rows.append(cur)
    finally:
        doc.close()
    for r in rows:
        r["segs"].sort(key=lambda s: s["x"])
        r["text"] = "".join(s["text"] for s in r["segs"])
    return rows


# ---------- 通用定位工具 ----------
def find_value(rows, label, page=None, right_of=0.0):
    """返回含 label 的行中 label 右侧最近的段文本；page 指定则只在该页。"""
    for r in rows:
        if page is not None and r["page"] != page:
            continue
        # label 在行首或行内含
        pos = r["text"].find(label)
        if pos < 0:
            continue
        x_lbl = r["segs"][0]["x"]  # 行内近似：以行为单位取右侧段
        cand = [s for s in r["segs"] if s["x"] > right_of + 1 and s["text"] != label]
        # 更精确：label 出现在某段开头，取该段之后同行的段
        for i, s in enumerate(r["segs"]):
            if label in s["text"] or (label and s["text"].startswith(label[:2])):
                for s2 in r["segs"][i + 1:]:
                    return s2["text"]
                break
        if cand:
            return cand[0]["text"]
    return ""


def party_info(rows, page=0):
    """购/销方两簇：同页出现两套 名称：/税号： 标签，按 x 聚左(购)/右(销)。"""
    def labels_row(label):
        out = []
        for r in rows:
            if r["page"] != page:
                continue
            for i, s in enumerate(r["segs"]):
                if s["text"] == label:
                    out.append((r, i))
        return out

    def fetch(label):
        hits = labels_row(label)
        if len(hits) < 2:
            return {}, {}
        xs = [r["segs"][i]["x"] for r, i in hits]
        sep = (min(xs) + max(xs)) / 2.0

        def cluster(x_lo, x_hi, key):
            info = {}
            for r, i in hits:
                if x_lo <= r["segs"][i]["x"] < x_hi and i + 1 < len(r["segs"]):
                    info[key] = r["segs"][i + 1]["text"]
            return info
        left = cluster(-1e9, sep, "名称")
        right = cluster(sep, 1e9, "名称")
        return left, right

    b_name, s_name = fetch(LBL_NAME)
    b_tax, s_tax = {}, {}
    # 税号：若与名称同行取右侧第2段，否则单独成行匹配
    for r in rows:
        if r["page"] != page:
            continue
        for i, s in enumerate(r["segs"]):
            if s["text"] == LBL_TAXID and i + 1 < len(r["segs"]):
                val = r["segs"][i + 1]["text"]
                x = s["x"]
                (b_tax if x < (min(xs) + max(xs)) / 2.0 else s_tax).setdefault("税号", val) 
                    if False else None
    # 简化：直接按行内 segs 顺序取
    return b_name, s_name


def _party_v2(rows, page=0):
    """稳健版：逐行扫描，识别 名称：/税号： 标签并把该行后续文本作为值；
    名称行与税号行可能不同 y，按 标签出现顺序（先名称后税号）与 x 簇归属购/销。"""
    seen = {"buyer": {}, "seller": {}}
    x_buy = x_sell = None
    for r in rows:
        if r["page"] != page:
            continue
        for i, s in enumerate(r["segs"]):
            if s["text"] == LBL_NAME:
                if x_buy is None or s["x"] < x_buy:
                    x_buy = s["x"]
            if s["text"] == LBL_TAXID:
                pass
        # 簇界
    # 以"名称："两个实例 x 定簇界
    name_xs = [s["x"] for r in rows if r["page"] == page
               for s in r["segs"] if s["text"] == LBL_NAME]
    if len(name_xs) < 2:
        return {}, {}
    sep = (min(name_xs) + max(name_xs)) / 2.0

    def pick(lb, side, key):
        for r in rows:
            if r["page"] != page:
                continue
            for i, s in enumerate(r["segs"]):
                if s["text"] == lb:
                    x = s["x"]
                    if (x < sep and side == "b") or (x >= sep and side == "s"):
                        if i + 1 < len(r["segs"]):
                            return r["segs"][i + 1]["text"]
        return ""

    buyer = {"购方名称": pick(LBL_NAME, "b", 1), "购方税号": pick(LBL_TAXID, "b", 1)}
    seller = {"销方名称": pick(LBL_NAME, "s", 1), "销方税号": pick(LBL_TAXID, "s", 1)}
    return buyer, seller


def col_bounds(rows, header_row):
    """明细表头行 → 列边界 [(列名, 右界)]"""
    hdr = {}
    for s in header_row["segs"]:
        if s["text"] in HEADERS:
            hdr.setdefault(HEADERS[s["text"]], s["x"])
    cols = sorted(hdr.items(), key=lambda kv: kv[1])
    bounds = []
    for i, (name, x0) in enumerate(cols):
        right = cols[i + 1][1] if i + 1 < len(cols) else 1e9
        b = (x0 + right) / 2.0 if i + 1 < len(cols) else 1e9
        if name in COL_OVERRIDE:
            b = COL_OVERRIDE[name]
        bounds.append([name, b])
    return bounds


def money_of_row(r):
    """行内金额段合并：兼容 ¥ 与数字拆段(¥ + 684.96)与整段(¥834.50)两种排布。"""
    out = []
    segs = sorted(r["segs"], key=lambda x: x["x"])
    i = 0
    while i < len(segs):
        t = segs[i]["text"]
        if t == "¥" and i + 1 < len(segs) and re.fullmatch(r"[d,.]+", segs[i + 1]["text"]):
            out.append("¥" + segs[i + 1]["text"])
            i += 2
            continue
        if t.startswith("¥"):
            out.append(t)
        i += 1
    return out


def row_label(r):
    """行左侧(x<150)非金额文本拼接：把跨格拆字(合/计、小/计)还原为逻辑标签。"""
    out = []
    for s in r["segs"]:
        if s["x"] < 150 and not s["text"].startswith(("¥", "-", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9")):
            out.append(s["text"])
    return "".join(out)


def page_items(rows, page, header_y, bounds):
    """单页明细：header_y 之后至 小计/合计 行前，每行一个 dict(列→文本)，名称跨行并入。"""
    bottom = None
    for r in rows:
        if r["page"] == page and r["y"] > header_y and r["text"] in ("合计", "小计"):
            bottom = r["y"] if bottom is None else min(bottom, r["y"])
    if bottom is None:
        bottom = 1e9
    num_cols = {"规格型号", "单位", "数量", "单价", "金额", "税率", "税额", "价税合计"}
    out = []
    for r in rows:
        if r["page"] != page or not (header_y < r["y"] < bottom):
            continue
        row = {}
        for s in r["segs"]:
            if s["text"] in HEADERS:
                continue
            col = "项目名称"
            for name, b in bounds:
                if s["x"] < b:
                    col = name
                    break
            row.setdefault(col, s["text"])
        if "项目名称" in row:
            # 数值列都空 → 视为名称续行
            if out and all(not row.get(c) for c in num_cols):
                out[-1]["项目名称"] += row["项目名称"]
            else:
                out.append(row)
    return out


def parse_pdf_invoice_v4(pdf_path):
    filename = pdf_path.rsplit("\", 1)[-1].rsplit("/", 1)[-1]
    try:
        rows = extract_rows(pdf_path)
    except Exception as e:
        return {"success": False, "error": f"PDF 打开失败: {e}"}
    if not rows:
        return {"success": False, "error": "PDF 无文字层，可能为扫描件，请改用 XML/OFD 原始数据或调用云端 API"}
    pages = sorted({r["page"] for r in rows})

    # 抬头
    title = ""
    for r in rows:
        for s in r["segs"]:
            if s["size"] >= 15 and ("电子发票" in s["text"] or "增值税" in s["text"]):
                title = s["text"]
    inv_no = find_value(rows, "发票号码：", page=pages[0])
    inv_date = find_value(rows, "开票日期：", page=pages[0])
    buyer, seller = _party_v2(rows, pages[0])

    # 开户行（跨页；"购方开户银行:" 文本段）
    for r in rows:
        for s in r["segs"]:
            if s["text"].startswith("购方开户银行"):
                m = re.match(r"购方开户银行[:：](.*?)[;；]?s*银行账号[:：](d+)", s["text"])
                if m:
                    buyer.setdefault("购方开户银行", m.group(1))
                    buyer.setdefault("购方开户行账号", m.group(2))
            elif s["text"].startswith("销方开户银行"):
                m = re.match(r"销方开户银行[:：](.*?)[;；]?s*银行账号[:：](d+)", s["text"])
                if m:
                    seller.setdefault("销方开户银行", m.group(1))
                    seller.setdefault("销方开户行账号", m.group(2))

    # 明细（逐页）
    items = []
    for pg in pages:
        header_row = None
        for r in rows:
            if r["page"] != pg:
                continue
            segtxt = {s["text"] for s in r["segs"]}
            if ("项目名称" in segtxt or "商品名称" in segtxt) and "规格型号" in segtxt:
                header_row = r
                break
        if header_row is None:
            continue
        bounds = col_bounds(rows, header_row)
        items.extend(page_items(rows, pg, header_row["y"], bounds))

    # 合计/小计（row_label 还原跨格"合计"；末页合计行 segs 内前两个 ¥ = 金额/税额合计）
    total_am = total_tax = ""
    for pg in sorted(pages, reverse=True):
        hit = [r for r in rows if r["page"] == pg and row_label(r) == "合计"]
        if not hit:
            continue
        r = hit[-1]
        moneys = money_of_row(r)
        if len(moneys) >= 2:
            total_am, total_tax = moneys[0], moneys[1]
        elif moneys:
            total_am = moneys[0]
        break

    # 价税合计 大写/小写（行标签"价税合计（大写）"；TOL_Y=4 保证 ¥/大写 与标签同簇）
    amt_cn = amt_small = ""
    for r in rows:
        if row_label(r) == "价税合计（大写）" or "价税合计（大写）" in r["text"]:
            for s in sorted(r["segs"], key=lambda x: x["x"]):
                if s["text"].startswith("¥") or s["text"] == "¥":
                    if not amt_small:
                        amt_small = "".join(x["text"] for x in sorted(
                            (p for p in r["segs"] if p["x"] >= s["x"]),
                            key=lambda x: x["x"]))[:24]
                elif ("圆" in s["text"] or "整" in s["text"]) and not amt_cn:
                    amt_cn = s["text"]
    if not amt_small:
        for r in rows:
            for s in r["segs"]:
                if s["text"].startswith("¥"):
                    amt_small = s["text"]
                    break
            if amt_small:
                break

    # 备注：备注标签行下方右侧内容
    remark = ""
    note_y = None
    for r in rows:
        if r["text"].startswith("备注") and any(s["x"] < 60 for s in r["segs"]):
            note_y = r["y"]
            break
    if note_y is not None:
        parts = []
        for r in rows:
            if note_y + 2 < r["y"] < note_y + 90 and any(s["x"] > 60 for s in r["segs"]):
                if r["text"].startswith(("备注", "开票人", "收款人", "复核人", "下载次数", "共")):
                    continue
                parts.append(r["text"])
        remark = " ".join(parts)

    drawer = ""
    for r in rows:
        for i, s in enumerate(r["segs"]):
            if s["text"].startswith("开票人") and i + 1 < len(r["segs"]):
                drawer = r["segs"][i + 1]["text"]
    if not drawer:
        drawer = find_value(rows, "开票人：")

    blue = ("红字发票(负数)" if any(("负" in v) or ("红冲" in v)
                                    for v in (amt_cn, remark, total_am)) else "蓝字发票")

    def clean(v):
        return (v or "").replace("¥", "")

    invoice = {
        "发票代码": "", "发票号码": inv_no, "开票日期": inv_date,
        "发票种类": title, "是否蓝字发票标志": blue,
        "价税合计": clean(amt_small), "价税合计大写": amt_cn,
        "不含税金额": clean(total_am), "税额": clean(total_tax),
        "销方名称": seller.get("销方名称", ""), "销方税号": seller.get("销方税号", ""),
        "销方地址": "", "销方电话": "",
        "销方开户银行": seller.get("销方开户银行", ""),
        "销方开户行账号": seller.get("销方开户行账号", ""),
        "购方名称": buyer.get("购方名称", ""), "购方税号": buyer.get("购方税号", ""),
        "购方地址": "", "购方电话": "",
        "购方开户银行": buyer.get("购方开户银行", ""),
        "购方开户行账号": buyer.get("购方开户行账号", ""),
        "开票人": drawer, "收款人": "", "复核人": "",
        "备注": remark, "附加信息": "", "请求时间": "", "特定业务": "",
        "税务机关代码": "", "税务机关名称": "",
        "商品明细": [{
            "商品名称": it.get("项目名称", ""), "项目名称": it.get("项目名称", ""),
            "规格型号": it.get("规格型号", ""), "单位": it.get("单位", ""),
            "数量": it.get("数量", ""), "单价": it.get("单价", ""),
            "金额": it.get("金额", ""), "税率": it.get("税率", ""),
            "税额": it.get("税额", ""), "价税合计": it.get("价税合计", ""),
            "商品分类编码": "",
        } for it in items],
        "original_name": filename,
        "parse_tier": 2,
        "parse_method": "pdf_layout_pymupdf",
    }
    return {"success": True, "invoice": invoice}

{
  "success": true,
  "invoice": {
    "发票代码": "${INVOICE_CODE}",
    "发票号码": "${INVOICE_NO}",
    "开票日期": "${INVOICE_DATE}",
    "价税合计": "${TOTAL_AMOUNT}",
    "价税合计大写": "${AMOUNT_CN}",
    "不含税金额": "${AMOUNT_EX_TAX}",
    "税额": "${TAX_AMOUNT}",
    "销方名称": "${SELLER_NAME}",
    "销方税号": "91****...****01",
    "销方地址": "${SELLER_ADDR}",
    "销方电话": "${SELLER_TEL}",
    "销方开户银行": "${SELLER_BANK}",
    "销方开户行账号": "${SELLER_ACCOUNT}",
    "购方名称": "${BUYER_NAME}",
    "购方税号": "91****...****02",
    "购方地址": "${BUYER_ADDR}",
    "购方电话": "${BUYER_TEL}",
    "购方开户银行": "${BUYER_BANK}",
    "购方开户行账号": "${BUYER_ACCOUNT}",
    "开票人": "${DRAWER}",
    "收款人": "${PAYEE}",
    "复核人": "${REVIEWER}",
    "备注": "${REMARKS}",
    "附加信息": "",
    "请求时间": "${REQUEST_TIME}",
    "是否蓝字发票标志": "${BLUE_FLAG}",
    "发票种类": "${INVOICE_TYPE}",
    "特定业务": "",
    "税务机关代码": "${TAX_BUREAU_CODE}",
    "税务机关名称": "${TAX_BUREAU_NAME}",
    "商品明细": [
      {
        "商品名称": "${ITEM_NAME}",
        "项目名称": "${ITEM_NAME}",
        "规格型号": "${ITEM_SPEC}",
        "单位": "${ITEM_UNIT}",
        "数量": "${ITEM_QTY}",
        "单价": "${ITEM_PRICE}",
        "金额": "${ITEM_AMOUNT}",
        "税率": "${ITEM_TAX_RATE}",
        "税额": "${ITEM_TAX}",
        "价税合计": "${ITEM_TOTAL}",
        "商品分类编码": "${TAX_CLASS_CODE}"
      }
    ],
    "original_name": "${ORIGINAL_FILE_NAME}",
    "parse_tier": 1,
    "parse_method": "xml_stdlib"
  }
}

{
  "success": true,
  "invoice": {
    "发票代码": "${INVOICE_CODE}",
    "发票号码": "${INVOICE_NO}",
    "开票日期": "${INVOICE_DATE}",
    "价税合计": "${TOTAL_AMOUNT}",
    "价税合计大写": "${AMOUNT_CN}",
    "不含税金额": "${AMOUNT_EX_TAX}",
    "税额": "${TAX_AMOUNT}",
    "销方名称": "${SELLER_NAME}",
    "销方税号": "91****...****01",
    "销方地址": "${SELLER_ADDR}",
    "销方电话": "${SELLER_TEL}",
    "销方开户银行": "${SELLER_BANK}",
    "销方开户行账号": "${SELLER_ACCOUNT}",
    "购方名称": "${BUYER_NAME}",
    "购方税号": "91****...****02",
    "购方地址": "${BUYER_ADDR}",
    "购方电话": "${BUYER_TEL}",
    "购方开户银行": "${BUYER_BANK}",
    "购方开户行账号": "${BUYER_ACCOUNT}",
    "开票人": "${DRAWER}",
    "收款人": "${PAYEE}",
    "复核人": "${REVIEWER}",
    "备注": "${REMARKS}",
    "附加信息": "",
    "请求时间": "${REQUEST_TIME}",
    "是否蓝字发票标志": "${BLUE_FLAG}",
    "发票种类": "${INVOICE_TYPE}",
    "特定业务": "",
    "税务机关代码": "${TAX_BUREAU_CODE}",
    "税务机关名称": "${TAX_BUREAU_NAME}",
    "商品明细": [
      {
        "商品名称": "${ITEM_NAME}",
        "项目名称": "${ITEM_NAME}",
        "规格型号": "${ITEM_SPEC}",
        "单位": "${ITEM_UNIT}",
        "数量": "${ITEM_QTY}",
        "单价": "${ITEM_PRICE}",
        "金额": "${ITEM_AMOUNT}",
        "税率": "${ITEM_TAX_RATE}",
        "税额": "${ITEM_TAX}",
        "价税合计": "${ITEM_TOTAL}",
        "商品分类编码": "${TAX_CLASS_CODE}"
      }
    ],
    "original_name": "${ORIGINAL_FILE_NAME}",
    "parse_tier": 1,
    "parse_method": "xml_stdlib"
  }
}

{
  "success": false,
  "error": "不支持的发票格式，支持格式：xml、ofd、pdf、zip"
}