SFM/app/pipeline/mapping.py

from __future__ import annotations

import json
import re
from dataclasses import dataclass
from pathlib import Path


@dataclass(frozen=True)
class MappingRule:
    column_name: str
    candidate_keys: tuple[str, ...]
    source: str = "any"


MAPPING_DATA_FILE = Path(__file__).resolve().with_name("mapping_table.json")
TARGET_REPORT_COLUMNS_COUNT = 203

_MANUAL_COLUMN_NAME_FIXES: dict[int, str] = {
    1: "Имя XML файла",
    178: "Место государственной регистрации ЕИО/Бенефициара (структура полностью)",
    183: "Номер",
}

_INVALID_TAGS = {"", "-", "Источник", "путь", "подразумеваются", "тэга", "нашла"}


def _load_mapping_data() -> list[dict[str, str | int]]:
    raw = json.loads(MAPPING_DATA_FILE.read_text(encoding="utf-8"))
    if not isinstance(raw, list):
        return []
    result: list[dict[str, str | int]] = []
    for item in raw:
        if not isinstance(item, dict):
            continue
        idx = int(item.get("index", 0))
        if not 1 <= idx <= TARGET_REPORT_COLUMNS_COUNT:
            continue
        column_name = str(item.get("column_name", "")).strip()
        xml_tag = str(item.get("xml_tag", "")).strip()
        xml_path = str(item.get("xml_path", "")).strip()
        if idx in _MANUAL_COLUMN_NAME_FIXES:
            column_name = _MANUAL_COLUMN_NAME_FIXES[idx]
        column_name = _cleanup_column_name(column_name)
        result.append(
            {
                "index": idx,
                "column_name": column_name,
                "xml_tag": xml_tag,
                "xml_path": xml_path,
            }
        )
    return sorted(result, key=lambda row: int(row["index"]))


def _cleanup_column_name(value: str) -> str:
    cleaned = re.sub(r"\s+", " ", value).strip()
    cleaned = re.sub(r"\s+не\s+нашла.*$", "", cleaned, flags=re.IGNORECASE)
    return cleaned.strip(" -")


def _build_fixed_columns(mapping_data: list[dict[str, str | int]]) -> tuple[str, ...]:
    columns: list[str] = []
    for row in mapping_data:
        column = str(row.get("column_name", "")).strip()
        columns.append(column or f"Колонка {row['index']}")
    if len(columns) < TARGET_REPORT_COLUMNS_COUNT:
        for index in range(len(columns) + 1, TARGET_REPORT_COLUMNS_COUNT + 1):
            columns.append(f"Колонка {index}")
    return tuple(columns[:TARGET_REPORT_COLUMNS_COUNT])


def _build_rules(mapping_data: list[dict[str, str | int]]) -> tuple[MappingRule, ...]:
    rules: list[MappingRule] = []
    participant_columns = {
        "Признак резидента участника",
        "Тип участника",
        "ИНН участника",
        "Наименование участника",
        "Счет участника",
    }
    for row in mapping_data:
        column = str(row.get("column_name", "")).strip()
        tag = str(row.get("xml_tag", "")).strip()
        path = str(row.get("xml_path", "")).strip()
        if not column or tag in _INVALID_TAGS:
            continue
        candidates = [tag]
        if column.startswith("ИНН "):
            candidates = ["ИННФЛ", "ИННЮЛ", "ИНН", *candidates]
        if column == "Тип участника":
            candidates = ["Тип", "ТипУчастника", *candidates]
        if path:
            path_tag = path.strip("/").split("/")[-1]
            if path_tag and path_tag not in candidates:
                candidates.append(path_tag)
        rules.append(
            MappingRule(
                column_name=column,
                candidate_keys=tuple(candidates),
                source=(
                    "participant"
                    if column in participant_columns or column.startswith("ИНН ")
                    else "any"
                ),
            )
        )
    return tuple(rules)


_MAPPING_DATA = _load_mapping_data()
FIXED_REPORT_COLUMNS: tuple[str, ...] = _build_fixed_columns(_MAPPING_DATA)
REPORT_MAPPING_RULES: tuple[MappingRule, ...] = _build_rules(_MAPPING_DATA)


def build_fixed_row(
    *,
    file_name: str,
    record_id: str,
    operation_index: int,
    operation_fields: dict[str, str],
    participant_fields: dict[str, str],
) -> dict[str, str]:
    row: dict[str, str] = {
        "Имя XML файла": file_name,
        "Идентификатор записи": record_id,
        "Уникальный номер операции": str(operation_index),
    }
    merged = _merge_fields(operation_fields, participant_fields)
    for rule in REPORT_MAPPING_RULES:
        if row.get(rule.column_name):
            continue
        source_payload = participant_fields if rule.source == "participant" else merged
        row[rule.column_name] = _pick_value(source_payload, rule.candidate_keys)
    for column in FIXED_REPORT_COLUMNS:
        row.setdefault(column, "")
    return row


def _merge_fields(
    operation_fields: dict[str, str],
    participant_fields: dict[str, str],
) -> dict[str, str]:
    merged: dict[str, str] = {}
    merged.update(operation_fields)
    merged.update(participant_fields)
    return merged


def _pick_value(payload: dict[str, str], candidates: tuple[str, ...]) -> str:
    for key in candidates:
        if key in payload and payload[key]:
            return payload[key]
        short = key.split(".")[-1]
        if short in payload and payload[short]:
            return payload[short]
    return ""