check_processed_data.py

from __future__ import annotations

import csv
import sys
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
from typing import Callable

# ============================================================
# Βασικά paths project
# ============================================================

BASE_DIR = Path(__file__).resolve().parents[1]
PROCESSED_DIR = BASE_DIR / "data" / "processed"

# Τύπος για custom validators
Validator = Callable[[str, list[dict[str, str]], list[str]], None]


# ============================================================
# Dataclass κανόνων ανά processed CSV αρχείο
# ============================================================


@dataclass(frozen=True)
class FileRule:
    """Κανόνες validation για ένα processed CSV αρχείο."""

    filename: str
    expected_headers: list[str]
    required_columns: list[str]
    unique_columns: list[str] = field(default_factory=list)
    composite_unique_keys: list[tuple[str, ...]] = field(default_factory=list)
    validators: list[Validator] = field(default_factory=list)


# ============================================================
# Βοηθητικές συναρτήσεις
# ============================================================


def is_blank(value: str | None) -> bool:
    """Επιστρέφει True αν η τιμή είναι κενή ή μόνο με κενά."""
    return value is None or str(value).strip() == ""


def add_error(errors: list[str], category: str, message: str) -> None:
    """Προσθέτει error με ενιαία μορφή για πιο καθαρό output."""
    errors.append(f"[{category}] {message}")


def read_csv_file(path: Path) -> tuple[list[str] | None, list[dict[str, str]]]:
    """
    Διαβάζει CSV με υποστήριξη BOM από Excel exports.
    Επιστρέφει headers και rows.
    """
    with path.open("r", encoding="utf-8-sig", newline="") as handle:
        reader = csv.DictReader(handle)
        headers = reader.fieldnames
        rows = list(reader)

    return headers, rows


def parse_date(value: str) -> bool:
    """Ελέγχει αν ένα string είναι valid ημερομηνία YYYY-MM-DD."""
    try:
        datetime.strptime(value.strip(), "%Y-%m-%d")
        return True
    except ValueError:
        return False


def parse_datetime(value: str) -> bool:
    """Ελέγχει αν ένα string είναι valid datetime YYYY-MM-DD HH:MM:SS."""
    try:
        datetime.strptime(value.strip(), "%Y-%m-%d %H:%M:%S")
        return True
    except ValueError:
        return False


# ============================================================
# Generic validators
# ============================================================


def validate_headers(
    filename: str,
    actual_headers: list[str] | None,
    expected_headers: list[str],
    errors: list[str],
) -> None:
    """Ελέγχει ότι τα headers είναι ακριβώς αυτά που περιμένουμε."""
    if actual_headers != expected_headers:
        add_error(
            errors,
            "HEADER",
            f"{filename}: expected {expected_headers}, found {actual_headers}",
        )


def validate_file_not_empty(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Ελέγχει ότι το αρχείο έχει τουλάχιστον 1 data row."""
    if not rows:
        add_error(errors, "EMPTY", f"{filename}: file contains no data rows")


def validate_required_columns(
    filename: str,
    rows: list[dict[str, str]],
    required_columns: list[str],
    errors: list[str],
) -> None:
    """Ελέγχει ότι τα required πεδία δεν είναι κενά."""
    for line_number, row in enumerate(rows, start=2):
        for column in required_columns:
            if is_blank(row.get(column)):
                add_error(
                    errors,
                    "BLANK",
                    f"{filename} line {line_number}: column '{column}' is blank",
                )


def validate_unique_columns(
    filename: str,
    rows: list[dict[str, str]],
    unique_columns: list[str],
    errors: list[str],
) -> None:
    """Ελέγχει uniqueness σε συγκεκριμένες στήλες."""
    for column in unique_columns:
        seen: set[str] = set()

        for line_number, row in enumerate(rows, start=2):
            value = (row.get(column) or "").strip()

            if is_blank(value):
                continue

            if value in seen:
                add_error(
                    errors,
                    "DUPLICATE",
                    f"{filename} line {line_number}: duplicate value '{value}' in column '{column}'",
                )
            else:
                seen.add(value)


def validate_composite_unique_keys(
    filename: str,
    rows: list[dict[str, str]],
    composite_keys: list[tuple[str, ...]],
    errors: list[str],
) -> None:
    """Ελέγχει uniqueness σε συνδυασμό στηλών."""
    for key_columns in composite_keys:
        seen: set[tuple[str, ...]] = set()

        for line_number, row in enumerate(rows, start=2):
            key = tuple((row.get(column) or "").strip() for column in key_columns)

            if any(is_blank(value) for value in key):
                continue

            if key in seen:
                add_error(
                    errors,
                    "DUPLICATE",
                    f"{filename} line {line_number}: duplicate composite key {key_columns}={key}",
                )
            else:
                seen.add(key)


def validate_positive_integer(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη είναι θετικός ακέραιος (> 0)."""
    for line_number, row in enumerate(rows, start=2):
        raw_value = row.get(column, "")

        if is_blank(raw_value):
            if allow_blank:
                continue
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        try:
            value = int(raw_value)
        except ValueError:
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' is not an integer",
            )
            continue

        if value <= 0:
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' must be > 0",
            )


def validate_non_negative_integer(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη είναι μη αρνητικός ακέραιος (>= 0)."""
    for line_number, row in enumerate(rows, start=2):
        raw_value = row.get(column, "")

        if is_blank(raw_value):
            if allow_blank:
                continue
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        try:
            value = int(raw_value)
        except ValueError:
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' is not an integer",
            )
            continue

        if value < 0:
            add_error(
                errors,
                "NUMBER",
                f"{filename} line {line_number}: '{column}' must be >= 0",
            )


def validate_allowed_values(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    allowed_values: set[str],
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη περιέχει μόνο επιτρεπτές τιμές."""
    for line_number, row in enumerate(rows, start=2):
        value = (row.get(column) or "").strip()

        if is_blank(value):
            if allow_blank:
                continue
            add_error(
                errors,
                "VALUE",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        if value not in allowed_values:
            add_error(
                errors,
                "VALUE",
                f"{filename} line {line_number}: '{column}' value '{value}' not in {sorted(allowed_values)}",
            )


def validate_date_column(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη έχει valid ημερομηνία YYYY-MM-DD."""
    for line_number, row in enumerate(rows, start=2):
        value = (row.get(column) or "").strip()

        if is_blank(value):
            if allow_blank:
                continue
            add_error(
                errors,
                "DATE",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        if not parse_date(value):
            add_error(
                errors,
                "DATE",
                f"{filename} line {line_number}: '{column}' value '{value}' is not YYYY-MM-DD",
            )


def validate_datetime_column(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη έχει valid datetime YYYY-MM-DD HH:MM:SS."""
    for line_number, row in enumerate(rows, start=2):
        value = (row.get(column) or "").strip()

        if is_blank(value):
            if allow_blank:
                continue
            add_error(
                errors,
                "DATETIME",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        if not parse_datetime(value):
            add_error(
                errors,
                "DATETIME",
                f"{filename} line {line_number}: '{column}' value '{value}' is not YYYY-MM-DD HH:MM:SS",
            )


# ============================================================
# Ειδικοί validators ανά processed αρχείο
# ============================================================


def validate_erp_systems(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για ERP systems."""
    validate_positive_integer(filename, rows, "erp_id", errors)
    validate_allowed_values(filename, rows, "role", {"Master of Products"}, errors)


def validate_categories(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για categories."""
    validate_positive_integer(filename, rows, "category_id", errors)


def validate_products(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για products."""
    validate_positive_integer(filename, rows, "erp_id", errors)
    validate_positive_integer(filename, rows, "category_id", errors)
    validate_non_negative_integer(filename, rows, "reorder_level", errors)
    validate_allowed_values(filename, rows, "status", {"Active", "Inactive"}, errors)


def validate_purchase_orders(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για purchase orders."""
    validate_date_column(filename, rows, "order_date", errors)
    validate_allowed_values(
        filename,
        rows,
        "status",
        {"Received", "Open", "Pending", "Cancelled"},
        errors,
    )


def validate_po_items(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για purchase order items."""
    validate_positive_integer(filename, rows, "ordered_qty", errors)


def validate_stock_lots(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για stock lots."""
    validate_positive_integer(filename, rows, "quantity", errors)
    validate_date_column(filename, rows, "received_date", errors, allow_blank=False)


def validate_movements(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για movements."""
    validate_positive_integer(filename, rows, "quantity", errors)
    validate_datetime_column(filename, rows, "movement_datetime", errors)
    validate_allowed_values(
        filename,
        rows,
        "movement_type",
        {"INBOUND", "PICK", "TRANSFER"},
        errors,
    )


def validate_alerts(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για alerts."""
    validate_datetime_column(filename, rows, "created_at", errors)
    validate_allowed_values(filename, rows, "alert_type", {"LOW_STOCK"}, errors)
    validate_allowed_values(
        filename,
        rows,
        "severity",
        {"LOW", "MEDIUM", "HIGH"},
        errors,
    )


def validate_erp_sync_log(
    filename: str,
    rows: list[dict[str, str]],
    errors: list[str],
) -> None:
    """Έλεγχοι για ERP sync log."""
    validate_allowed_values(
        filename,
        rows,
        "sync_action",
        {"UPSERT", "DELETE"},
        errors,
    )


# ============================================================
# Configuration πραγματικών processed αρχείων
# ============================================================

FILE_RULES: list[FileRule] = [
    FileRule(
        filename="erp_systems.csv",
        expected_headers=["erp_id", "name", "role"],
        required_columns=["erp_id", "name", "role"],
        unique_columns=["erp_id", "name"],
        validators=[validate_erp_systems],
    ),
    FileRule(
        filename="categories.csv",
        expected_headers=["category_id", "name"],
        required_columns=["category_id", "name"],
        unique_columns=["category_id", "name"],
        validators=[validate_categories],
    ),
    FileRule(
        filename="products.csv",
        expected_headers=[
            "product_id",
            "erp_id",
            "category_id",
            "sku",
            "name",
            "reorder_level",
            "status",
        ],
        required_columns=[
            "product_id",
            "erp_id",
            "category_id",
            "sku",
            "name",
            "reorder_level",
            "status",
        ],
        unique_columns=["product_id", "sku"],
        validators=[validate_products],
    ),
    FileRule(
        filename="suppliers.csv",
        expected_headers=["supplier_id", "name", "country"],
        required_columns=["supplier_id", "name", "country"],
        unique_columns=["supplier_id"],
    ),
    FileRule(
        filename="product_suppliers.csv",
        expected_headers=["product_id", "supplier_id"],
        required_columns=["product_id", "supplier_id"],
        composite_unique_keys=[("product_id", "supplier_id")],
    ),
    FileRule(
        filename="warehouses.csv",
        expected_headers=["warehouse_id", "name", "city"],
        required_columns=["warehouse_id", "name", "city"],
        unique_columns=["warehouse_id"],
    ),
    FileRule(
        filename="zones.csv",
        expected_headers=["zone_id", "warehouse_id", "name"],
        required_columns=["zone_id", "warehouse_id", "name"],
        unique_columns=["zone_id"],
    ),
    FileRule(
        filename="bins.csv",
        expected_headers=["bin_id", "zone_id", "shelf"],
        required_columns=["bin_id", "zone_id", "shelf"],
        unique_columns=["bin_id"],
    ),
    FileRule(
        filename="purchase_orders.csv",
        expected_headers=["po_id", "order_date", "status"],
        required_columns=["po_id", "order_date", "status"],
        unique_columns=["po_id"],
        validators=[validate_purchase_orders],
    ),
    FileRule(
        filename="po_items.csv",
        expected_headers=["po_item_id", "po_id", "product_id", "supplier_id", "ordered_qty"],
        required_columns=["po_item_id", "po_id", "product_id", "supplier_id", "ordered_qty"],
        unique_columns=["po_item_id"],
        validators=[validate_po_items],
    ),
    FileRule(
        filename="stock_lots.csv",
        expected_headers=["lot_id", "product_id", "bin_id", "po_item_id", "quantity", "received_date"],
        required_columns=["lot_id", "product_id", "bin_id", "quantity", "received_date"],
        unique_columns=["lot_id"],
        validators=[validate_stock_lots],
    ),
    FileRule(
        filename="employees.csv",
        expected_headers=["employee_id", "name", "role"],
        required_columns=["employee_id", "name", "role"],
        unique_columns=["employee_id"],
    ),
    FileRule(
        filename="movements.csv",
        expected_headers=[
            "movement_id",
            "product_id",
            "lot_id",
            "from_bin_id",
            "to_bin_id",
            "employee_id",
            "movement_type",
            "quantity",
            "movement_datetime",
        ],
        required_columns=[
            "movement_id",
            "product_id",
            "lot_id",
            "employee_id",
            "movement_type",
            "quantity",
            "movement_datetime",
        ],
        unique_columns=["movement_id"],
        validators=[validate_movements],
    ),
    FileRule(
        filename="alerts.csv",
        expected_headers=[
            "alert_id",
            "product_id",
            "warehouse_id",
            "alert_type",
            "severity",
            "created_at",
        ],
        required_columns=[
            "alert_id",
            "product_id",
            "warehouse_id",
            "alert_type",
            "severity",
            "created_at",
        ],
        unique_columns=["alert_id"],
        validators=[validate_alerts],
    ),
    FileRule(
        filename="erp_sync_log.csv",
        expected_headers=["product_id", "sync_action", "source_system"],
        required_columns=["product_id", "sync_action", "source_system"],
        validators=[validate_erp_sync_log],
    ),
]


# ============================================================
# Cross-file helper functions
# ============================================================


def build_key_set(rows: list[dict[str, str]], column: str) -> set[str]:
    """Φτιάχνει σύνολο valid keys από μία στήλη."""
    return {
        (row.get(column) or "").strip()
        for row in rows
        if not is_blank(row.get(column))
    }


def build_lookup(
    rows: list[dict[str, str]],
    key_column: str,
) -> dict[str, dict[str, str]]:
    """Φτιάχνει lookup dictionary για γρήγορη πρόσβαση ανά key."""
    lookup: dict[str, dict[str, str]] = {}

    for row in rows:
        key = (row.get(key_column) or "").strip()
        if not is_blank(key):
            lookup[key] = row

    return lookup


def validate_foreign_key(
    filename: str,
    rows: list[dict[str, str]],
    column: str,
    valid_keys: set[str],
    errors: list[str],
    allow_blank: bool = False,
) -> None:
    """Ελέγχει ότι μια στήλη δείχνει σε valid key άλλου αρχείου."""
    for line_number, row in enumerate(rows, start=2):
        value = (row.get(column) or "").strip()

        if is_blank(value):
            if allow_blank:
                continue

            add_error(
                errors,
                "FK",
                f"{filename} line {line_number}: '{column}' is blank",
            )
            continue

        if value not in valid_keys:
            add_error(
                errors,
                "FK",
                f"{filename} line {line_number}: '{column}' value '{value}' does not exist in referenced dataset",
            )


# ============================================================
# Cross-file validation
# ============================================================


def validate_cross_file_integrity(
    datasets: dict[str, list[dict[str, str]]],
    errors: list[str],
) -> None:
    """Ελέγχει referential integrity και βασικούς domain κανόνες μεταξύ αρχείων."""

    erp_systems = datasets["erp_systems.csv"]
    categories = datasets["categories.csv"]
    products = datasets["products.csv"]
    suppliers = datasets["suppliers.csv"]
    product_suppliers = datasets["product_suppliers.csv"]
    warehouses = datasets["warehouses.csv"]
    zones = datasets["zones.csv"]
    bins = datasets["bins.csv"]
    purchase_orders = datasets["purchase_orders.csv"]
    po_items = datasets["po_items.csv"]
    stock_lots = datasets["stock_lots.csv"]
    employees = datasets["employees.csv"]
    movements = datasets["movements.csv"]
    alerts = datasets["alerts.csv"]
    erp_sync_log = datasets["erp_sync_log.csv"]

    erp_ids = build_key_set(erp_systems, "erp_id")
    erp_names = build_key_set(erp_systems, "name")
    category_ids = build_key_set(categories, "category_id")
    product_ids = build_key_set(products, "product_id")
    supplier_ids = build_key_set(suppliers, "supplier_id")
    warehouse_ids = build_key_set(warehouses, "warehouse_id")
    zone_ids = build_key_set(zones, "zone_id")
    bin_ids = build_key_set(bins, "bin_id")
    po_ids = build_key_set(purchase_orders, "po_id")
    po_item_ids = build_key_set(po_items, "po_item_id")
    lot_ids = build_key_set(stock_lots, "lot_id")
    employee_ids = build_key_set(employees, "employee_id")

    # --------------------------------------------------------
    # Απλά foreign key checks
    # --------------------------------------------------------

    validate_foreign_key("products.csv", products, "erp_id", erp_ids, errors)
    validate_foreign_key("products.csv", products, "category_id", category_ids, errors)

    validate_foreign_key("zones.csv", zones, "warehouse_id", warehouse_ids, errors)
    validate_foreign_key("bins.csv", bins, "zone_id", zone_ids, errors)

    validate_foreign_key(
        "product_suppliers.csv",
        product_suppliers,
        "product_id",
        product_ids,
        errors,
    )
    validate_foreign_key(
        "product_suppliers.csv",
        product_suppliers,
        "supplier_id",
        supplier_ids,
        errors,
    )

    validate_foreign_key("po_items.csv", po_items, "po_id", po_ids, errors)
    validate_foreign_key("po_items.csv", po_items, "product_id", product_ids, errors)
    validate_foreign_key("po_items.csv", po_items, "supplier_id", supplier_ids, errors)

    validate_foreign_key("stock_lots.csv", stock_lots, "product_id", product_ids, errors)
    validate_foreign_key("stock_lots.csv", stock_lots, "bin_id", bin_ids, errors)
    validate_foreign_key(
        "stock_lots.csv",
        stock_lots,
        "po_item_id",
        po_item_ids,
        errors,
        allow_blank=True,  # Το LOT1003 είναι σωστά blank στο τωρινό dataset
    )

    validate_foreign_key("movements.csv", movements, "product_id", product_ids, errors)
    validate_foreign_key("movements.csv", movements, "lot_id", lot_ids, errors)
    validate_foreign_key("movements.csv", movements, "employee_id", employee_ids, errors)
    validate_foreign_key(
        "movements.csv",
        movements,
        "from_bin_id",
        bin_ids,
        errors,
        allow_blank=True,
    )
    validate_foreign_key(
        "movements.csv",
        movements,
        "to_bin_id",
        bin_ids,
        errors,
        allow_blank=True,
    )

    validate_foreign_key("alerts.csv", alerts, "product_id", product_ids, errors)
    validate_foreign_key("alerts.csv", alerts, "warehouse_id", warehouse_ids, errors)

    validate_foreign_key(
        "erp_sync_log.csv",
        erp_sync_log,
        "product_id",
        product_ids,
        errors,
    )

    # Το source_system του sync log πρέπει να υπάρχει ως ERP system name
    validate_foreign_key(
        "erp_sync_log.csv",
        erp_sync_log,
        "source_system",
        erp_names,
        errors,
    )

    # --------------------------------------------------------
    # Domain consistency checks
    # --------------------------------------------------------

    po_item_lookup = build_lookup(po_items, "po_item_id")
    stock_lot_lookup = build_lookup(stock_lots, "lot_id")
    zone_lookup = build_lookup(zones, "zone_id")
    bin_lookup = build_lookup(bins, "bin_id")

    # Αν ένα stock lot έχει po_item_id, τότε το product_id πρέπει να ταιριάζει
    for line_number, row in enumerate(stock_lots, start=2):
        po_item_id = (row.get("po_item_id") or "").strip()

        if is_blank(po_item_id):
            continue

        lot_product_id = (row.get("product_id") or "").strip()
        po_item = po_item_lookup.get(po_item_id)

        if po_item is None:
            continue

        po_item_product_id = (po_item.get("product_id") or "").strip()

        if lot_product_id != po_item_product_id:
            add_error(
                errors,
                "CONSISTENCY",
                f"stock_lots.csv line {line_number}: product_id '{lot_product_id}' does not match po_item product_id '{po_item_product_id}'",
            )

    # Το movement.product_id πρέπει να συμφωνεί με το product_id του lot
    for line_number, row in enumerate(movements, start=2):
        movement_product_id = (row.get("product_id") or "").strip()
        lot_id = (row.get("lot_id") or "").strip()

        stock_lot = stock_lot_lookup.get(lot_id)

        if stock_lot is None:
            continue

        lot_product_id = (stock_lot.get("product_id") or "").strip()

        if movement_product_id != lot_product_id:
            add_error(
                errors,
                "CONSISTENCY",
                f"movements.csv line {line_number}: product_id '{movement_product_id}' does not match stock_lot product_id '{lot_product_id}'",
            )

    # Το from_bin_id και to_bin_id, όταν υπάρχουν, δεν πρέπει να είναι ίδια
    for line_number, row in enumerate(movements, start=2):
        from_bin_id = (row.get("from_bin_id") or "").strip()
        to_bin_id = (row.get("to_bin_id") or "").strip()

        if not is_blank(from_bin_id) and not is_blank(to_bin_id) and from_bin_id == to_bin_id:
            add_error(
                errors,
                "CONSISTENCY",
                f"movements.csv line {line_number}: from_bin_id and to_bin_id cannot be the same",
            )

    # Ένας bin ανήκει σε zone και η zone πρέπει να είναι valid
    for line_number, row in enumerate(bins, start=2):
        zone_id = (row.get("zone_id") or "").strip()

        if zone_id not in zone_lookup:
            add_error(
                errors,
                "CONSISTENCY",
                f"bins.csv line {line_number}: zone_id '{zone_id}' does not exist",
            )

    # Επιπλέον λογικός έλεγχος για movement types
    for line_number, row in enumerate(movements, start=2):
        movement_type = (row.get("movement_type") or "").strip()
        from_bin_id = (row.get("from_bin_id") or "").strip()
        to_bin_id = (row.get("to_bin_id") or "").strip()

        if movement_type == "TRANSFER":
            if is_blank(from_bin_id) or is_blank(to_bin_id):
                add_error(
                    errors,
                    "MOVEMENT",
                    f"movements.csv line {line_number}: TRANSFER requires both from_bin_id and to_bin_id",
                )

        if movement_type == "PICK":
            if is_blank(from_bin_id):
                add_error(
                    errors,
                    "MOVEMENT",
                    f"movements.csv line {line_number}: PICK requires from_bin_id",
                )

    # Προαιρετικός έλεγχος: bin references μέσα στα movements όντως υπάρχουν
    for line_number, row in enumerate(movements, start=2):
        from_bin_id = (row.get("from_bin_id") or "").strip()
        to_bin_id = (row.get("to_bin_id") or "").strip()

        if not is_blank(from_bin_id) and from_bin_id not in bin_lookup:
            add_error(
                errors,
                "MOVEMENT",
                f"movements.csv line {line_number}: from_bin_id '{from_bin_id}' not found in bins.csv",
            )

        if not is_blank(to_bin_id) and to_bin_id not in bin_lookup:
            add_error(
                errors,
                "MOVEMENT",
                f"movements.csv line {line_number}: to_bin_id '{to_bin_id}' not found in bins.csv",
            )


# ============================================================
# Κύρια διαδικασία validation
# ============================================================


def validate_processed_directory() -> list[str]:
    """Τρέχει όλα τα checks πάνω στον φάκελο data/processed."""
    errors: list[str] = []

    if not PROCESSED_DIR.exists():
        add_error(errors, "FOLDER", f"Processed folder not found: {PROCESSED_DIR}")
        return errors

    existing_files = {path.name for path in PROCESSED_DIR.glob("*.csv")}
    expected_files = {rule.filename for rule in FILE_RULES}

    missing_files = sorted(expected_files - existing_files)
    unexpected_files = sorted(existing_files - expected_files)

    for filename in missing_files:
        add_error(errors, "MISSING FILE", filename)

    for filename in unexpected_files:
        add_error(errors, "UNEXPECTED FILE", filename)

    datasets: dict[str, list[dict[str, str]]] = {}

    for rule in FILE_RULES:
        file_path = PROCESSED_DIR / rule.filename

        if not file_path.exists():
            continue

        headers, rows = read_csv_file(file_path)
        datasets[rule.filename] = rows

        validate_headers(rule.filename, headers, rule.expected_headers, errors)
        validate_file_not_empty(rule.filename, rows, errors)
        validate_required_columns(rule.filename, rows, rule.required_columns, errors)

        if rule.unique_columns:
            validate_unique_columns(rule.filename, rows, rule.unique_columns, errors)

        if rule.composite_unique_keys:
            validate_composite_unique_keys(
                rule.filename,
                rows,
                rule.composite_unique_keys,
                errors,
            )

        for validator in rule.validators:
            validator(rule.filename, rows, errors)

    # Cross-file checks μόνο αν υπάρχουν όλα τα αναμενόμενα datasets
    if not missing_files and len(datasets) == len(FILE_RULES):
        validate_cross_file_integrity(datasets, errors)

    return errors


def print_summary(errors: list[str]) -> None:
    """Εκτυπώνει καθαρό summary αποτελεσμάτων."""
    if errors:
        print("PROCESSED DATA VALIDATION FAILED")
        print("-" * 60)
        for error in errors:
            print(error)
        return

    print("PROCESSED DATA VALIDATION PASSED")
    print(f"Checked folder: {PROCESSED_DIR}")
    print(f"Checked files: {len(FILE_RULES)}")


def main() -> None:
    """Entry point του script."""
    errors = validate_processed_directory()
    print_summary(errors)

    if errors:
        sys.exit(1)

    sys.exit(0)


if __name__ == "__main__":
    main()