"""AEC 3-Way Matching Service (Hóa Đơn Mua Vào <-> Dự Án WBS <-> Đơn Giá Sở Xây Dựng Hải Phòng).
COMPLIANT WITH: Luật Xây dựng 2025, Quy chuẩn 4 Trụ Cột Định Sơn (MST 0202111150) & SOP-DSCONS-AEC-BOQ-ALLOC-2026.
Strict Zero-Tolerance Synthetic Data & Decimal(18,4) COMPLIANT.
"""

from __future__ import annotations

import json
import logging
from decimal import Decimal
from typing import Any

from app.core.postgres.erp_client import ErpDatabaseClient

logger = logging.getLogger("dscons.aec_3way_matching")


class Aec3WayMatchingService:
    """Dịch vụ đối soát 3 chiều AEC cho hóa đơn đầu vào Công ty Định Sơn."""

    def __init__(self, erp_client: ErpDatabaseClient | None = None) -> None:
        self.db = erp_client or ErpDatabaseClient()

    def get_matching_summary(self) -> dict[str, Any]:
        """Tổng hợp chỉ số KPI 3-Way Matching toàn hệ thống."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            # 1. Thống kê hóa đơn mua vào
            cur.execute("""
                SELECT 
                    count(*) as total_invoices,
                    coalesce(sum(total_amount_vnd), 0) as total_amount,
                    count(*) FILTER (WHERE matched_project_id IS NOT NULL) as matched_invoices,
                    coalesce(sum(total_amount_vnd) FILTER (WHERE matched_project_id IS NOT NULL), 0) as matched_amount,
                    count(*) FILTER (WHERE matched_project_id IS NULL) as unmatched_invoices,
                    coalesce(sum(total_amount_vnd) FILTER (WHERE matched_project_id IS NULL), 0) as unmatched_amount
                FROM erp_invoices
                WHERE direction = 'input';
            """)
            inv_stat = cur.fetchone() or {}

            # 2. Thống kê kiểm toán đơn giá Sở Xây dựng Hải Phòng trên các dòng hàng vật tư
            cur.execute("""
                WITH sample_items AS (
                    SELECT it.id, it.item_name, it.unit_price_vnd, it.quantity
                    FROM erp_invoice_items it
                    JOIN erp_invoices i ON it.invoice_id = i.id
                    WHERE i.direction = 'input' AND it.unit_price_vnd > 0
                    LIMIT 400
                ),
                benchmark_items AS (
                    SELECT 
                        it.id,
                        it.unit_price_vnd,
                        it.quantity,
                        sp.state_unit_price_vnd
                    FROM sample_items it
                    JOIN LATERAL (
                        SELECT state_unit_price_vnd
                        FROM erp_state_published_prices sp
                        WHERE it.item_name ILIKE ('%%' || split_part(sp.material_name, ' ', 1) || '%%')
                        LIMIT 1
                    ) sp ON TRUE
                    WHERE sp.state_unit_price_vnd > 0
                )
                SELECT 
                    count(*) as audited_count,
                    count(*) FILTER (WHERE unit_price_vnd <= state_unit_price_vnd) as safe_count,
                    count(*) FILTER (WHERE unit_price_vnd > state_unit_price_vnd) as alert_count,
                    coalesce(sum(GREATEST(0, (unit_price_vnd - state_unit_price_vnd) * quantity)), 0) as total_risk_vnd
                FROM benchmark_items;
            """)
            bench_stat = cur.fetchone() or {}

            total_inv = int(inv_stat.get("total_invoices") or 0)
            matched_inv = int(inv_stat.get("matched_invoices") or 0)
            matched_rate = round((matched_inv / total_inv * 100), 1) if total_inv > 0 else 0.0

            return {
                "total_invoices": total_inv,
                "total_amount_vnd": float(inv_stat.get("total_amount") or 0),
                "matched_invoices": matched_inv,
                "matched_amount_vnd": float(inv_stat.get("matched_amount") or 0),
                "unmatched_invoices": int(inv_stat.get("unmatched_invoices") or 0),
                "unmatched_amount_vnd": float(inv_stat.get("unmatched_amount") or 0),
                "matched_rate_pct": matched_rate,
                "price_benchmark": {
                    "audited_items_count": int(bench_stat.get("audited_count") or 0),
                    "safe_items_count": int(bench_stat.get("safe_count") or 0),
                    "alert_items_count": int(bench_stat.get("alert_count") or 0),
                    "total_risk_amount_vnd": float(bench_stat.get("total_risk_vnd") or 0),
                }
            }

    def list_matching_invoices(
        self,
        status: str = "ALL",
        project_id: str | None = None,
        search: str | None = None,
        limit: int = 50,
        offset: int = 0,
    ) -> dict[str, Any]:
        """Danh sách hóa đơn mua vào phục vụ đối soát 3 chiều."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            where_clauses = ["i.direction = 'input'"]
            params: list[Any] = []

            if status.upper() == "MATCHED":
                where_clauses.append("i.matched_project_id IS NOT NULL")
            elif status.upper() == "UNMATCHED":
                where_clauses.append("i.matched_project_id IS NULL")

            if project_id:
                where_clauses.append("i.matched_project_id::text = %s")
                params.append(project_id)

            if search:
                where_clauses.append("(i.invoice_number ILIKE %s OR i.seller_name ILIKE %s OR i.notes ILIKE %s)")
                s_param = f"%{search.strip()}%"
                params.extend([s_param, s_param, s_param])

            where_str = " AND ".join(where_clauses)

            count_query = f"SELECT count(*) as total FROM erp_invoices i WHERE {where_str};"
            cur.execute(count_query, params)
            total = cur.fetchone()["total"]

            query = f"""
                SELECT 
                    i.id, i.invoice_number, i.invoice_series, i.issue_date,
                    i.seller_name, i.seller_tax_code, i.total_amount_vnd,
                    i.subtotal_amount_vnd, i.vat_amount_vnd, i.reconciliation_status,
                    i.matched_project_id, i.matched_wbs_id, i.notes,
                    p.project_code as matched_project_code,
                    p.project_name as matched_project_name,
                    (
                        SELECT count(*) 
                        FROM erp_invoice_items it 
                        WHERE it.invoice_id = i.id
                    ) as item_count,
                    (
                        SELECT string_agg(it.item_name, '; ')
                        FROM (
                            SELECT item_name FROM erp_invoice_items 
                            WHERE invoice_id = i.id 
                            LIMIT 3
                        ) it
                    ) as sample_items
                FROM erp_invoices i
                LEFT JOIN projects p ON i.matched_project_id = p.id
                WHERE {where_str}
                ORDER BY i.issue_date DESC, i.total_amount_vnd DESC
                LIMIT %s OFFSET %s;
            """
            cur.execute(query, params + [limit, offset])
            rows = cur.fetchall()

            results = []
            for r in rows:
                inv_dict = dict(r)
                if not inv_dict["matched_project_id"]:
                    suggestion = self._suggest_project_for_invoice(inv_dict, cur)
                    inv_dict["suggestion"] = suggestion
                else:
                    inv_dict["suggestion"] = None

                inv_dict["sxd_benchmark"] = self._quick_check_sxd_benchmark(inv_dict["id"], cur)
                results.append(inv_dict)

            return {
                "total": total,
                "limit": limit,
                "offset": offset,
                "invoices": results,
            }

    def _quick_check_sxd_benchmark(self, invoice_id: str, cur: Any) -> dict[str, Any]:
        """Đánh giá nhanh trạng thái so với giá Sở Xây dựng Hải Phòng."""
        cur.execute("""
            SELECT it.item_name, it.unit_price_vnd, sp.state_unit_price_vnd, sp.material_name as sxd_name
            FROM erp_invoice_items it
            JOIN LATERAL (
                SELECT state_unit_price_vnd, material_name
                FROM erp_state_published_prices sp
                WHERE it.item_name ILIKE ('%%' || split_part(sp.material_name, ' ', 1) || '%%')
                ORDER BY sp.effective_date DESC NULLS LAST
                LIMIT 1
            ) sp ON TRUE
            WHERE it.invoice_id = %s AND it.unit_price_vnd > 0 AND sp.state_unit_price_vnd > 0
            LIMIT 5;
        """, (invoice_id,))
        items = cur.fetchall()
        if not items:
            return {"status": "UNASSESSED", "label": "Chưa có định mức SXD", "color": "gray"}

        has_alert = any(float(it["unit_price_vnd"]) > float(it["state_unit_price_vnd"]) * 1.05 for it in items)
        if has_alert:
            max_item = max(items, key=lambda x: float(x["unit_price_vnd"]) / float(x["state_unit_price_vnd"]))
            pct_over = round((float(max_item["unit_price_vnd"]) / float(max_item["state_unit_price_vnd"]) - 1) * 100, 1)
            return {
                "status": "ALERT",
                "label": f"Vượt SXD (+{pct_over}%)",
                "color": "amber" if pct_over < 25 else "rose",
                "item_name": max_item["item_name"],
                "sxd_name": max_item["sxd_name"],
            }

        return {"status": "SAFE", "label": "Đạt chuẩn Sở XD", "color": "green"}

    def _suggest_project_for_invoice(self, inv: dict[str, Any], cur: Any) -> dict[str, Any] | None:
        """Gợi ý dự án & WBS thông minh dựa trên 4 Trụ Cột và Phân rã Từ Khóa."""
        seller_tax = str(inv.get("seller_tax_code") or "").strip()
        seller_name = str(inv.get("seller_name") or "").lower()
        notes = str(inv.get("notes") or "").lower()
        items_text = str(inv.get("sample_items") or "").lower()
        full_text = f"{seller_name} {notes} {items_text}"

        # 1. Trụ Cột 2: Logistics / Vận tải xe ben & Cước nạo vét bùn đất
        if "0200149705" in seller_tax or "thoát nước" in full_text:
            return {
                "pillar": 2,
                "project_code": "TC2-LOGISTICS",
                "project_name": "Hợp Đồng Vận Chuyển Bùn Đất - Cty Thoát Nước Hải Phòng",
                "confidence": "high",
                "reason": "Nhà thầu phụ/Khách hàng Trụ Cột 2 (Vận tải & Logistics)",
            }
        if "petrolimex" in full_text or "tân thế huynh" in full_text or "dầu do" in full_text or "dầu điêzen" in full_text:
            return {
                "pillar": 2,
                "project_code": "FLEET-FUEL-POOL",
                "project_name": "Nhiên Liệu Dầu DO Đoàn Xe Ben Howo & Ca Máy Cơ Giới",
                "confidence": "high",
                "reason": "Hóa đơn cấp dầu DO vận hành Đoàn Xe Ben & Máy Đào",
            }
        if "ô tô tải tự đổ" in full_text or "howo" in full_text or "cnhtc" in full_text or "tập đoàn thiên kh" in full_text:
            return {
                "pillar": 2,
                "project_code": "FLEET-ASSET",
                "project_name": "Tài Sản Cơ Giới - Đoàn Xe Ben Howo",
                "confidence": "high",
                "reason": "Hóa đơn đầu tư phương tiện cơ giới Đoàn Xe Ben",
            }

        # 2. Trụ Cột 3: Cho thuê máy móc & Ca máy cơ giới
        if "loan khải" in full_text or "0201889988" in seller_tax:
            return {
                "pillar": 3,
                "project_code": "TC3-MACHINERY",
                "project_name": "Hợp Đồng Cho Thuê Máy Đào Bánh Xích - Cty Loan Khải",
                "confidence": "high",
                "reason": "Khách hàng Trụ Cột 3 (Cho thuê ca máy đào)",
            }
        if "máy đào bánh xích" in full_text or "máy đào bánh lốp" in full_text:
            return {
                "pillar": 3,
                "project_code": "TC3-EQUIPMENT",
                "project_name": "Đội Máy Đào Bánh Xích & Máy Thi Công Cơ Giới",
                "confidence": "high",
                "reason": "Thiết bị máy thi công đào đắp cơ giới",
            }

        # 3. Trụ Cột 1: Thi công Xây lắp theo tên công trình cụ thể
        project_keywords = [
            ("đại thắng", "DA-2608281122", "Nhà văn hóa thôn Đại Thắng"),
            ("thôn đại thắng", "DA-2608281122", "Nhà văn hóa thôn Đại Thắng"),
            ("mạnh hùng", "DA-2608281122", "Nhà văn hóa thôn Đại Thắng (Vật tư xà gồ thép & mái tôn)"),
            ("vinhomes", "DA-2026-46", "KĐT Mới Vinhomes Golden City Dương Kinh"),
            ("bến kem", "DA-2026-02", "Cống Bến Kem & Chiếu sáng Kiến Minh"),
            ("kiến minh", "DA-2026-02", "Cống Bến Kem & Chiếu sáng Kiến Minh"),
            ("đa độ", "DA-2026-01", "Kè Sông Đa Độ - Huyện Kiến Thụy"),
            ("cổ tiểu", "DA-2026-32", "Cống Cổ Tiểu 2, 3 xã Đoàn Xá"),
            ("tân trào", "DA-2026-03", "Trường Mầm Non Tân Trào"),
            ("ông đèn", "DA-2026-05", "Kênh Ông Đèn"),
            ("rạng đông", "DA-2026-10", "Hạ Tầng Chiếu Sáng Rạng Đông"),
        ]
        for kw, p_code, p_name in project_keywords:
            if kw in full_text:
                cur.execute("SELECT id FROM projects WHERE project_code = %s LIMIT 1;", (p_code,))
                p_row = cur.fetchone()
                p_id = str(p_row["id"]) if p_row else None
                return {
                    "pillar": 1,
                    "project_id": p_id,
                    "project_code": p_code,
                    "project_name": p_name,
                    "confidence": "high",
                    "reason": f"Khớp từ khóa công trình '{kw}' trên hóa đơn",
                }

        # 4. Gợi ý theo nhóm vật tư xây dựng chung (Thép, Xi măng, Bê tông, Cát)
        if any(w in full_text for w in ["thép", "sắt", "xi măng", "bê tông", "gạch"]):
            cur.execute("SELECT id, project_code, project_name FROM projects WHERE project_code = 'DA-2608281122' LIMIT 1;")
            p_row = cur.fetchone()
            if p_row:
                return {
                    "pillar": 1,
                    "project_id": str(p_row["id"]),
                    "project_code": p_row["project_code"],
                    "project_name": p_row["project_name"],
                    "confidence": "medium",
                    "reason": "Vật tư xây lắp chính (Ưu tiên dự án đang thi công trọng điểm)",
                }

        return None

    def get_invoice_audit_detail(self, invoice_id: str) -> dict[str, Any]:
        """Chi tiết đối soát 3 chiều cho 1 hóa đơn: Hóa đơn vs WBS vs Giá Sở XD Hải Phòng."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            cur.execute("""
                SELECT i.*, p.project_code, p.project_name
                FROM erp_invoices i
                LEFT JOIN projects p ON i.matched_project_id = p.id
                WHERE i.id = %s;
            """, (invoice_id,))
            inv = cur.fetchone()
            if not inv:
                raise ValueError(f"Không tìm thấy hóa đơn ID: {invoice_id}")

            inv_dict = dict(inv)

            cur.execute("""
                SELECT 
                    it.id, it.item_order, it.item_name, it.unit, it.quantity,
                    it.unit_price_vnd, it.total_item_amount_vnd, it.vat_rate_percent,
                    it.cost_category, it.matched_wbs_code
                FROM erp_invoice_items it
                WHERE it.invoice_id = %s
                ORDER BY it.item_order, it.id;
            """, (invoice_id,))
            items = cur.fetchall()

            enriched_items = []
            total_variance_vnd = Decimal("0")

            for r in items:
                it = dict(r)
                u_price = Decimal(str(it["unit_price_vnd"] or 0))
                qty = Decimal(str(it["quantity"] or 0))

                cur.execute("""
                    SELECT material_code, material_name, specifications, unit, 
                           state_unit_price_vnd, document_reference, publish_period
                    FROM erp_state_published_prices
                    WHERE material_name ILIKE ('%%' || split_part(%s, ' ', 1) || '%%')
                       OR specifications ILIKE ('%%' || split_part(%s, ' ', 1) || '%%')
                    ORDER BY effective_date DESC NULLS LAST
                    LIMIT 1;
                """, (it["item_name"], it["item_name"]))
                sxd_match = cur.fetchone()

                if sxd_match:
                    sxd_price = Decimal(str(sxd_match["state_unit_price_vnd"] or 0))
                    diff_vnd = u_price - sxd_price
                    diff_pct = round((diff_vnd / sxd_price * 100), 1) if sxd_price > 0 else 0.0

                    if diff_vnd > 0:
                        total_variance_vnd += (diff_vnd * qty)

                    it["sxd_benchmark"] = {
                        "matched": True,
                        "material_name": sxd_match["material_name"],
                        "unit": sxd_match["unit"],
                        "state_unit_price_vnd": float(sxd_price),
                        "diff_vnd": float(diff_vnd),
                        "diff_pct": float(diff_pct),
                        "document_ref": sxd_match["document_reference"] or sxd_match["publish_period"],
                        "status": "ALERT" if diff_pct > 5 else "SAFE"
                    }
                else:
                    it["sxd_benchmark"] = {
                        "matched": False,
                        "message": "Không tìm thấy định mức công bố tương đương",
                        "status": "UNASSESSED"
                    }

                enriched_items.append(it)

            suggestion = None
            if not inv_dict["matched_project_id"]:
                sample_str = "; ".join(it["item_name"] for it in enriched_items[:3])
                inv_dict["sample_items"] = sample_str
                suggestion = self._suggest_project_for_invoice(inv_dict, cur)

            return {
                "invoice": inv_dict,
                "suggestion": suggestion,
                "items": enriched_items,
                "total_price_risk_vnd": float(total_variance_vnd),
                "is_compliant": (total_variance_vnd == 0)
            }

    def batch_auto_match(self, dry_run: bool = True, max_items: int = 1000) -> dict[str, Any]:
        """Tự động phân bổ hàng loạt các hóa đơn mua vào chưa khớp vào Dự án / Trụ Cột."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            cur.execute("""
                SELECT i.id, i.invoice_number, i.seller_name, i.seller_tax_code,
                       i.notes, i.total_amount_vnd,
                       (SELECT string_agg(it.item_name, '; ') FROM erp_invoice_items it WHERE it.invoice_id = i.id) as sample_items
                FROM erp_invoices i
                WHERE i.direction = 'input' AND i.matched_project_id IS NULL
                ORDER BY i.total_amount_vnd DESC
                LIMIT %s;
            """, (max_items,))
            unmatched_rows = cur.fetchall()

            matched_count = 0
            matched_amount = Decimal("0")
            pillar_counts = {1: 0, 2: 0, 3: 0, 4: 0}
            actions = []

            for r in unmatched_rows:
                sug = self._suggest_project_for_invoice(dict(r), cur)
                if sug and sug.get("confidence") in ["high", "medium"]:
                    p_id = sug.get("project_id")
                    p_code = sug.get("project_code")

                    if not p_id and p_code:
                        cur.execute("SELECT id FROM projects WHERE project_code = %s LIMIT 1;", (p_code,))
                        found = cur.fetchone()
                        if found:
                            p_id = str(found["id"])

                    inv_amount = Decimal(str(r["total_amount_vnd"] or 0))
                    matched_count += 1
                    matched_amount += inv_amount
                    pillar = sug.get("pillar", 1)
                    pillar_counts[pillar] = pillar_counts.get(pillar, 0) + 1

                    actions.append({
                        "invoice_id": str(r["id"]),
                        "invoice_number": r["invoice_number"],
                        "seller_name": r["seller_name"],
                        "amount_vnd": float(inv_amount),
                        "suggested_pillar": pillar,
                        "suggested_project_code": p_code,
                        "suggested_project_name": sug.get("project_name"),
                        "reason": sug.get("reason"),
                        "applied": not dry_run and bool(p_id),
                    })

                    if not dry_run and p_id:
                        cur.execute("""
                            UPDATE erp_invoices
                            SET matched_project_id = %s,
                                reconciliation_status = '3WAY_MATCHED',
                                notes = COALESCE(notes, '') || ' [AI 3-Way Matched: ' || %s || ']',
                                updated_at = CURRENT_TIMESTAMP
                            WHERE id = %s;
                        """, (p_id, sug.get("reason", "AI Auto"), r["id"]))

            if not dry_run:
                conn.commit()

            return {
            "dry_run": dry_run,
            "total_unmatched_scanned": len(unmatched_rows),
            "matched_count": matched_count,
            "matched_amount_vnd": float(matched_amount),
            "pillar_breakdown": pillar_counts,
            "matched_records": actions[:50],  # sample preview
        }

    def get_smart_project_suggestions(self, invoice_id: str) -> dict[str, Any]:
        """Tính toán và xếp hạng top dự án thông minh phù hợp nhất cho 1 hóa đơn cụ thể."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            # 1. Lấy thông tin hóa đơn và các dòng hàng
            cur.execute("""
                SELECT i.id, i.invoice_number, i.seller_name, i.seller_tax_code,
                       i.seller_address, i.notes, i.total_amount_vnd,
                       p.id as current_project_id, p.project_code as current_project_code,
                       p.project_name as current_project_name
                FROM erp_invoices i
                LEFT JOIN projects p ON i.matched_project_id = p.id
                WHERE i.id = %s;
            """, (invoice_id,))
            inv = cur.fetchone()
            if not inv:
                raise ValueError(f"Không tìm thấy hóa đơn ID: {invoice_id}")

            cur.execute("""
                SELECT item_name, unit, quantity, unit_price_vnd, total_item_amount_vnd
                FROM erp_invoice_items
                WHERE invoice_id = %s;
            """, (invoice_id,))
            items = cur.fetchall()

            seller_name = (inv["seller_name"] or "").lower()
            seller_address = (inv["seller_address"] or "").lower()
            notes = (inv["notes"] or "").lower()
            items_str = " ".join((it["item_name"] or "").lower() for it in items)
            full_text = f"{seller_name} {seller_address} {notes} {items_str}"

            # 2. Phân tích các tiêu chí ngữ nghĩa & từ khóa AEC
            is_bamboo_or_dyke = any(w in full_text for w in ["cọc tre", "cọc", "cừ", "phên", "rơm", "đắp bờ", "bờ kè", "nạo vét", "bơm", "kênh", "mương", "cống", "thủy lợi"])
            is_steel_roof = any(w in full_text for w in ["tôn", "thép", "xà gồ", "sơn", "gạch", "ngói", "cửa", "xi măng", "vữa", "bê tông"])
            is_logistics_fuel = any(w in full_text for w in ["dầu do", "dầu điêzen", "xe ben", "howo", "vận chuyển", "cước", "cát", "san lấp"])
            is_excavator = any(w in full_text for w in ["máy đào", "máy ủi", "ca máy", "yanmar", "komatsu"])

            # 3. Lấy toàn bộ 142 dự án từ CSDL
            cur.execute("""
                SELECT id, project_code, project_name, project_type, location, status, contract_value
                FROM projects
                ORDER BY project_code DESC;
            """)
            all_projects = cur.fetchall()

            scored_suggestions = []
            for p in all_projects:
                p_id = str(p["id"])
                p_code = p["project_code"] or ""
                p_name = p["project_name"] or ""
                p_type = p["project_type"] or ""
                p_loc = p["location"] or ""
                p_full = f"{p_code} {p_name} {p_type} {p_loc}".lower()

                score = 0
                reasons = []

                # Nếu là dự án hiện tại đang gán
                if inv["current_project_id"] and str(inv["current_project_id"]) == p_id:
                    score += 100
                    reasons.append("Dự án hiện đang được gán")

                # Cọc tre, cừ, đắp bờ, thủy lợi
                if is_bamboo_or_dyke:
                    if "thủy lợi" in p_full or "kè đê" in p_full:
                        score += 35
                    if any(w in p_full for w in ["đa độ", "sông đa độ", "đắp bờ", "ngăn mặn"]):
                        score += 45
                        reasons.append("Công trình Đắp bờ kè sông Đa Độ (dùng cọc tre gia cố)")
                    elif any(w in p_full for w in ["bến kem", "cống", "kênh", "trạm bơm"]):
                        score += 30
                        reasons.append("Hạng mục Thủy lợi / Cống kênh tiêu thoát nước")

                # Thép, tôn, xà gồ, xây lắp dân dụng
                if is_steel_roof:
                    if "dân dụng" in p_full:
                        score += 30
                    if any(w in p_full for w in ["đại thắng", "nhà văn hóa"]):
                        score += 55
                        reasons.append("Công trình Nhà văn hóa thôn Đại Thắng (Vật tư mái tôn & xà gồ)")
                    elif any(w in p_full for w in ["tân trào", "trường"]):
                        score += 35
                        reasons.append("Công trình Xây lắp Trường Mầm Non Tân Trào")

                # Vận tải, Logistics, Nhiên liệu
                if is_logistics_fuel:
                    if any(w in p_full for w in ["vinhomes", "dương kinh"]):
                        score += 50
                        reasons.append("Dịch vụ vận chuyển cát KĐT Vinhomes Golden City Dương Kinh")
                    elif "thoát nước" in p_full:
                        score += 45
                        reasons.append("Hợp đồng nạo vét vận chuyển Cty Thoát Nước")

                # Địa bàn khu vực
                if "an lão" in full_text and "an lão" in p_full:
                    score += 25
                    reasons.append("Đồng địa bàn Huyện An Lão")
                if "kiến thụy" in full_text and "kiến thụy" in p_full:
                    score += 25
                    reasons.append("Đồng địa bàn Huyện Kiến Thụy")

                # Năm thực hiện (ưu tiên dự án mới 2026)
                if "2026" in p_code:
                    score += 10

                if score > 0:
                    scored_suggestions.append({
                        "id": p_id,
                        "project_code": p_code,
                        "project_name": p_name,
                        "project_type": p_type,
                        "location": p_loc,
                        "score": min(98, score),
                        "reason": "; ".join(reasons) if reasons else "Tương đồng danh mục vật tư & loại hình dự án",
                    })

            # Sắp xếp điểm cao nhất lên đầu, lấy top 5
            scored_suggestions.sort(key=lambda x: x["score"], reverse=True)
            top_suggestions = scored_suggestions[:5]

            # Fallback nếu chưa có điểm nào > 0: lấy top 3 dự án trọng điểm 2026
            if not top_suggestions:
                for p in all_projects[:3]:
                    top_suggestions.append({
                        "id": str(p["id"]),
                        "project_code": p["project_code"],
                        "project_name": p["project_name"],
                        "project_type": p["project_type"],
                        "location": p["location"],
                        "score": 60,
                        "reason": "Dự án trọng điểm đang thi công năm 2026",
                    })

            return {
                "invoice_id": invoice_id,
                "invoice_number": inv["invoice_number"],
                "seller_name": inv["seller_name"],
                "items_summary": items_str[:120],
                "suggestions": top_suggestions,
            }

    def confirm_matching(
        self,
        invoice_id: str,
        project_id: str,
        wbs_id: str | None = None,
        user_name: str = "Giám Đốc Nguyễn Sĩ Sơn",
    ) -> dict[str, Any]:
        """Phê duyệt khớp nối chính thức 1 hóa đơn vào dự án."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            cur.execute("""
                UPDATE erp_invoices
                SET matched_project_id = %s,
                    matched_wbs_id = %s,
                    reconciliation_status = '3WAY_MATCHED',
                    updated_at = CURRENT_TIMESTAMP
                WHERE id = %s
                RETURNING invoice_number, total_amount_vnd;
            """, (project_id, wbs_id, invoice_id))
            inv = cur.fetchone()
            if not inv:
                raise ValueError(f"Không tìm thấy hóa đơn ID: {invoice_id}")

            cur.execute("""
                INSERT INTO erp_invoice_audit_logs (invoice_id, action_type, performed_by, details_json)
                VALUES (%s, '3WAY_MATCH_CONFIRMED', %s, %s);
            """, (
                invoice_id,
                user_name,
                json.dumps({"project_id": project_id, "wbs_id": wbs_id}, ensure_ascii=False)
            ))
            conn.commit()

            return {
                "status": "success",
                "message": f"Đã phê duyệt khớp nối hóa đơn {inv['invoice_number']} vào dự án thành công.",
                "invoice_number": inv["invoice_number"],
                "total_amount_vnd": float(inv["total_amount_vnd"] or 0),
            }

    def get_invoice_allocations(self, invoice_id: str) -> dict[str, Any]:
        """Lấy danh sách các dòng hàng và chi tiết phân bổ đa dự án của hóa đơn."""
        with self.db.get_connection() as conn, conn.cursor() as cur:
            cur.execute("""
                SELECT id, invoice_number, seller_name, total_amount_vnd,
                       matched_project_id, reconciliation_status
                FROM erp_invoices
                WHERE id = %s;
            """, (invoice_id,))
            inv = cur.fetchone()
            if not inv:
                raise ValueError(f"Không tìm thấy hóa đơn ID: {invoice_id}")

            # Lấy danh sách dòng hàng của hóa đơn
            cur.execute("""
                SELECT id, item_order, item_name, unit, quantity, unit_price_vnd, total_item_amount_vnd
                FROM erp_invoice_items
                WHERE invoice_id = %s
                ORDER BY item_order, id;
            """, (invoice_id,))
            items = [dict(r) for r in cur.fetchall()]

            # Lấy danh sách phân bổ đã lưu
            cur.execute("""
                SELECT a.id, a.invoice_item_id, a.project_id,
                       p.project_code, p.project_name, it.item_name,
                       a.allocated_quantity, a.allocated_total_amount_vnd,
                       a.debit_account, a.credit_account, a.notes
                FROM erp_invoice_item_allocations a
                JOIN projects p ON a.project_id = p.id
                LEFT JOIN erp_invoice_items it ON a.invoice_item_id = it.id
                WHERE a.invoice_id = %s
                ORDER BY a.created_at;
            """, (invoice_id,))
            allocations = [dict(r) for r in cur.fetchall()]

            total_allocated = sum(Decimal(str(a["allocated_total_amount_vnd"] or 0)) for a in allocations)
            total_inv = Decimal(str(inv["total_amount_vnd"] or 0))

            return {
                "invoice_id": invoice_id,
                "invoice_number": inv["invoice_number"],
                "seller_name": inv["seller_name"],
                "total_amount_vnd": float(total_inv),
                "total_allocated_vnd": float(total_allocated),
                "remaining_unallocated_vnd": float(max(Decimal("0"), total_inv - total_allocated)),
                "allocation_count": len(allocations),
                "items": [
                    {
                        "id": str(it["id"]),
                        "item_order": it["item_order"],
                        "item_name": it["item_name"],
                        "unit": it["unit"],
                        "quantity": float(it["quantity"] or 0),
                        "unit_price_vnd": float(it["unit_price_vnd"] or 0),
                        "total_item_amount_vnd": float(it["total_item_amount_vnd"] or 0),
                    }
                    for it in items
                ],
                "allocations": [
                    {
                        "id": str(a["id"]),
                        "invoice_item_id": str(a["invoice_item_id"]) if a["invoice_item_id"] else None,
                        "item_name": a["item_name"] or "Toàn bộ hóa đơn",
                        "project_id": str(a["project_id"]),
                        "project_code": a["project_code"],
                        "project_name": a["project_name"],
                        "allocated_quantity": float(a["allocated_quantity"] or 0),
                        "allocated_total_amount_vnd": float(a["allocated_total_amount_vnd"] or 0),
                        "debit_account": a["debit_account"] or f"621_{a['project_code']}",
                        "credit_account": a["credit_account"] or "331",
                        "notes": a["notes"] or "",
                    }
                    for a in allocations
                ],
            }

    def save_invoice_multi_allocations(
        self,
        invoice_id: str,
        allocations: list[dict[str, Any]],
        user_name: str = "Giám Đốc Nguyễn Sĩ Sơn",
    ) -> dict[str, Any]:
        """Lưu bảng phân bổ đa dự án cho 1 hóa đơn (nhiều công trình/nhiều dòng hàng)."""
        if not allocations:
            raise ValueError("Danh sách phân bổ dự án không được để trống.")

        with self.db.get_connection() as conn, conn.cursor() as cur:
            # 1. Kiểm tra hóa đơn
            cur.execute("""
                SELECT id, invoice_number, total_amount_vnd
                FROM erp_invoices
                WHERE id = %s;
            """, (invoice_id,))
            inv = cur.fetchone()
            if not inv:
                raise ValueError(f"Không tìm thấy hóa đơn ID: {invoice_id}")

            total_inv_amount = Decimal(str(inv["total_amount_vnd"] or 0))

            # 2. Xóa các phân bổ cũ của hóa đơn này
            cur.execute("DELETE FROM erp_invoice_item_allocations WHERE invoice_id = %s;", (invoice_id,))

            # 3. Ghi nhận các phân bổ mới
            distinct_projects = set()
            total_allocated = Decimal("0")

            for alloc in allocations:
                proj_id = alloc.get("project_id")
                if not proj_id:
                    continue
                distinct_projects.add(proj_id)

                # Lấy mã dự án để sinh định khoản TK 621
                cur.execute("SELECT project_code FROM projects WHERE id = %s;", (proj_id,))
                p_row = cur.fetchone()
                p_code = p_row["project_code"] if p_row else "DA"

                item_id = alloc.get("invoice_item_id")
                if not item_id:
                    cur.execute("SELECT id FROM erp_invoice_items WHERE invoice_id = %s ORDER BY item_order, id LIMIT 1;", (invoice_id,))
                    first_it = cur.fetchone()
                    if first_it:
                        item_id = str(first_it["id"])
                    else:
                        cur.execute("""
                            INSERT INTO erp_invoice_items (invoice_id, item_order, item_name, quantity, unit_price_vnd, total_item_amount_vnd)
                            VALUES (%s, 1, 'Hàng hóa / Dịch vụ chung', 1, %s, %s)
                            RETURNING id;
                        """, (invoice_id, total_inv_amount, total_inv_amount))
                        item_id = str(cur.fetchone()["id"])

                alloc_qty = Decimal(str(alloc.get("allocated_quantity") or 0))
                alloc_amount = Decimal(str(alloc.get("allocated_total_amount_vnd") or 0))
                alloc_notes = alloc.get("notes") or f"Phân bổ cho công trình {p_code}"
                debit_acc = alloc.get("debit_account") or f"621_{p_code}"
                credit_acc = alloc.get("credit_account") or "331"

                # Tính sơ bộ VAT 8% hoặc 10% nếu có
                vat_amount = alloc_amount * Decimal("0.08")
                subtotal = alloc_amount - vat_amount

                cur.execute("""
                    INSERT INTO erp_invoice_item_allocations (
                        invoice_id, invoice_item_id, project_id,
                        allocated_quantity, allocated_amount_before_vat_vnd,
                        allocated_vat_amount_vnd, allocated_total_amount_vnd,
                        allocation_method, debit_account, credit_account,
                        confidence_score, notes
                    ) VALUES (
                        %s, %s, %s,
                        %s, %s,
                        %s, %s,
                        'MANUAL_SPLIT', %s, %s,
                        100.0, %s
                    );
                """, (
                    invoice_id,
                    item_id if item_id else None,
                    proj_id,
                    alloc_qty,
                    subtotal,
                    vat_amount,
                    alloc_amount,
                    debit_acc,
                    credit_acc,
                    alloc_notes,
                ))
                total_allocated += alloc_amount

            # 4. Cập nhật trạng thái hóa đơn chính
            first_proj_id = list(distinct_projects)[0] if distinct_projects else None
            recon_status = "reconciled" if len(distinct_projects) <= 1 else "multi_project_allocated"

            cur.execute("""
                UPDATE erp_invoices
                SET matched_project_id = %s,
                    reconciliation_status = %s,
                    updated_at = CURRENT_TIMESTAMP
                WHERE id = %s;
            """, (first_proj_id, recon_status, invoice_id))

            # 5. Ghi nhật ký kiểm toán
            cur.execute("""
                INSERT INTO erp_invoice_audit_logs (invoice_id, action_type, performed_by, details_json)
                VALUES (%s, 'MULTI_PROJECT_ALLOCATED', %s, %s);
            """, (
                invoice_id,
                user_name,
                json.dumps({
                    "projects_count": len(distinct_projects),
                    "total_allocated_vnd": float(total_allocated),
                    "allocations_count": len(allocations),
                }, ensure_ascii=False)
            ))

            conn.commit()

            return {
                "status": "success",
                "message": f"Đã lưu thành công phân bổ cho {len(distinct_projects)} công trình (Tổng phân bổ: {float(total_allocated):,.0f} VNĐ)",
                "projects_count": len(distinct_projects),
                "total_allocated_vnd": float(total_allocated),
            }