from __future__ import annotations

import math
import re
from collections import defaultdict
from pathlib import Path

import cadquery as cq


OUTPUT_ROOT = Path(r"C:\Users\User\Desktop")
STEP_NAME = "cli_040_ap242_quality_out.step"
REPORT_NAME = "cli_040_quality_report.txt"
TOL = 0.08

PART_BBOXES = [
    (-25.0, 25.0, -20.0, 20.0, 0.0, 20.0),
    (35.0, 75.0, -17.5, 17.5, 0.0, 18.0),
    (85.0, 115.0, -12.5, 12.5, 0.0, 16.0),
    (121.0, 149.0, -11.0, 11.0, 0.0, 14.0),
    (156.0, 180.0, -10.0, 10.0, 0.0, 12.0),
    (187.0, 207.0, -8.0, 8.0, 0.0, 10.0),
]
ASSEMBLY_BBOX = (-25.0, 207.0, -20.0, 20.0, 0.0, 20.0)

ENTITY_RE = re.compile(r"^\s*#(\d+)\s*=\s*(.+)\s*$", re.DOTALL)
REF_RE = re.compile(r"#(\d+)")
NUMBER = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?"


def split_part21(text: str) -> list[str]:
    text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
    statements: list[str] = []
    current: list[str] = []
    quoted = False
    index = 0
    while index < len(text):
        char = text[index]
        current.append(char)
        if char == "'":
            if quoted and index + 1 < len(text) and text[index + 1] == "'":
                current.append(text[index + 1])
                index += 1
            else:
                quoted = not quoted
        elif char == ";" and not quoted:
            statement = "".join(current[:-1]).strip()
            if statement:
                statements.append(statement)
            current = []
        index += 1
    if quoted or "".join(current).strip():
        raise ValueError("unterminated STEP statement")
    return statements


def parse_part21(path: Path):
    if not path.is_file() or path.stat().st_size < 4096:
        raise ValueError("missing or implausibly small STEP file")
    text = path.read_text(encoding="utf-8", errors="strict")
    statements = split_part21(text)
    entities: dict[int, str] = {}
    header: list[str] = []
    for statement in statements:
        match = ENTITY_RE.match(statement)
        if match:
            entity_id = int(match.group(1))
            if entity_id in entities:
                raise ValueError("duplicate entity id")
            entities[entity_id] = match.group(2).strip()
        else:
            header.append(statement)
    if not entities:
        raise ValueError("STEP has no entities")
    return entities, header


def refs(body: str) -> list[int]:
    return [int(value) for value in REF_RE.findall(body)]


def has_type(body: str, entity_type: str) -> bool:
    return re.search(rf"(?<![A-Z0-9_]){re.escape(entity_type)}\s*\(", body.upper()) is not None


def check_schema(header: list[str]) -> bool:
    schemas = [item.upper() for item in header if item.upper().startswith("FILE_SCHEMA")]
    return (
        len(schemas) == 1
        and "AP242" in schemas[0]
        and "AUTOMOTIVE_DESIGN" not in schemas[0]
        and "CONFIG_CONTROL_DESIGN" not in schemas[0]
    )


def check_millimeter_contexts(entities: dict[int, str]) -> bool:
    contexts = {
        entity_id: body
        for entity_id, body in entities.items()
        if has_type(body, "GEOMETRIC_REPRESENTATION_CONTEXT")
        and has_type(body, "GLOBAL_UNIT_ASSIGNED_CONTEXT")
    }
    if not contexts:
        return False
    millimeter = re.compile(
        r"SI_UNIT\s*\(\s*\.MILLI\.\s*,\s*\.METRE\.\s*\)", re.IGNORECASE
    )
    for context in contexts.values():
        match = re.search(
            r"GLOBAL_UNIT_ASSIGNED_CONTEXT\s*\(\s*\(([^)]*)\)\s*\)",
            context,
            re.IGNORECASE,
        )
        if not match:
            return False
        unit_ids = [int(value) for value in REF_RE.findall(match.group(1))]
        length_units = [
            entities.get(unit_id, "")
            for unit_id in unit_ids
            if has_type(entities.get(unit_id, ""), "LENGTH_UNIT")
        ]
        if len(length_units) != 1 or not millimeter.search(length_units[0]):
            return False
    used_contexts = set()
    for body in entities.values():
        if has_type(body, "SHAPE_REPRESENTATION"):
            linked = refs(body)
            if not linked:
                return False
            used_contexts.add(linked[-1])
    return bool(used_contexts) and used_contexts <= set(contexts)


def check_references(entities: dict[int, str]) -> bool:
    defined = set(entities)
    return all(set(refs(body)) <= defined for body in entities.values())


def load_solids(path: Path):
    solids = cq.importers.importStep(str(path)).solids().vals()
    if len(solids) != 6 or any(not solid.isValid() for solid in solids):
        raise ValueError("expected six valid solids")
    return solids


def bbox_tuple(solid):
    box = solid.BoundingBox()
    return (box.xmin, box.xmax, box.ymin, box.ymax, box.zmin, box.zmax)


def close_tuple(actual, expected, tolerance=TOL) -> bool:
    return len(actual) == len(expected) and all(
        abs(float(a) - float(e)) <= tolerance for a, e in zip(actual, expected)
    )


def check_geometry(solids) -> bool:
    unmatched = list(solids)
    for expected in PART_BBOXES:
        match = next(
            (solid for solid in unmatched if close_tuple(bbox_tuple(solid), expected)),
            None,
        )
        if match is None:
            return False
        dx = expected[1] - expected[0]
        dy = expected[3] - expected[2]
        dz = expected[5] - expected[4]
        if abs(float(match.Volume()) - dx * dy * dz) > 1.0:
            return False
        if len(match.Faces()) != 6:
            return False
        unmatched.remove(match)
    return not unmatched


def shape_product_map(entities: dict[int, str], solid_ids: set[int]) -> dict[int, int]:
    advanced_to_solids: dict[int, set[int]] = {}
    for entity_id, body in entities.items():
        if has_type(body, "ADVANCED_BREP_SHAPE_REPRESENTATION"):
            linked = set(refs(body)) & solid_ids
            if linked:
                advanced_to_solids[entity_id] = linked

    shape_to_solids: dict[int, set[int]] = defaultdict(set)
    for body in entities.values():
        if not has_type(body, "SHAPE_REPRESENTATION_RELATIONSHIP"):
            continue
        linked = refs(body)
        advanced = [value for value in linked if value in advanced_to_solids]
        shapes = [
            value
            for value in linked
            if value in entities
            and has_type(entities[value], "SHAPE_REPRESENTATION")
            and not has_type(entities[value], "SHAPE_REPRESENTATION_RELATIONSHIP")
            and value not in advanced_to_solids
        ]
        for advanced_id in advanced:
            for shape_id in shapes:
                shape_to_solids[shape_id].update(advanced_to_solids[advanced_id])

    pds_to_product: dict[int, int] = {}
    for entity_id, body in entities.items():
        if has_type(body, "PRODUCT_DEFINITION_SHAPE"):
            linked = refs(body)
            product_defs = [
                value
                for value in linked
                if value in entities and has_type(entities[value], "PRODUCT_DEFINITION")
            ]
            if len(product_defs) == 1:
                pds_to_product[entity_id] = product_defs[0]

    result: dict[int, int] = {}
    for body in entities.values():
        if not has_type(body, "SHAPE_DEFINITION_REPRESENTATION"):
            continue
        linked = refs(body)
        pds = [value for value in linked if value in pds_to_product]
        shapes = [value for value in linked if value in shape_to_solids]
        if len(pds) != 1 or len(shapes) != 1:
            continue
        product_def = pds_to_product[pds[0]]
        for solid_id in shape_to_solids[shapes[0]]:
            if solid_id in result and result[solid_id] != product_def:
                raise ValueError("solid mapped to multiple product definitions")
            result[solid_id] = product_def
    return result


def check_assembly(entities: dict[int, str], solid_ids: set[int]) -> bool:
    if len(solid_ids) != 6:
        return False
    solid_products = shape_product_map(entities, solid_ids)
    if set(solid_products) != solid_ids or len(set(solid_products.values())) != 6:
        return False

    edges: set[tuple[int, int]] = set()
    for body in entities.values():
        if has_type(body, "NEXT_ASSEMBLY_USAGE_OCCURRENCE"):
            linked = refs(body)
            if len(linked) >= 2:
                edges.add((linked[-2], linked[-1]))
    part_products = set(solid_products.values())
    children = {child for _, child in edges}
    if not part_products <= children:
        return False
    if any(parent in part_products for parent, _ in edges):
        return False

    parents = {parent for parent, _ in edges}
    roots = parents - children
    adjacency: dict[int, set[int]] = defaultdict(set)
    for parent, child in edges:
        adjacency[parent].add(child)

    def reachable(root: int) -> set[int]:
        seen: set[int] = set()
        stack = [root]
        while stack:
            current = stack.pop()
            if current in seen:
                continue
            seen.add(current)
            stack.extend(adjacency.get(current, ()))
        return seen

    return any(part_products <= reachable(root) for root in roots)


def color_entities(entities: dict[int, str]) -> dict[int, tuple[float, float, float]]:
    pattern = re.compile(
        rf"COLOUR_RGB\s*\(\s*'(?:''|[^'])*'\s*,\s*({NUMBER})\s*,\s*({NUMBER})\s*,\s*({NUMBER})\s*\)",
        re.IGNORECASE,
    )
    result = {}
    for entity_id, body in entities.items():
        match = pattern.search(body)
        if match:
            color = tuple(float(match.group(index)) for index in range(1, 4))
            if not all(math.isfinite(value) and 0.0 <= value <= 1.0 for value in color):
                raise ValueError("invalid RGB value")
            result[entity_id] = color
    return result


def descendants(start: int, entities: dict[int, str]) -> set[int]:
    seen: set[int] = set()
    stack = [start]
    while stack:
        current = stack.pop()
        if current in seen or current not in entities:
            continue
        seen.add(current)
        stack.extend(refs(entities[current]))
    return seen


def check_colors(entities: dict[int, str], solid_ids: set[int]) -> bool:
    colors = color_entities(entities)
    if len(colors) < 6:
        return False

    style_pattern = re.compile(
        r"(?:CONTEXT_DEPENDENT_OVER_RIDING_)?STYLED_ITEM\s*\(\s*'(?:''|[^'])*'\s*,\s*\(([^)]*)\)\s*,\s*#(\d+)",
        re.IGNORECASE,
    )
    target_colors: dict[int, set[tuple[float, float, float]]] = defaultdict(set)
    for body in entities.values():
        match = style_pattern.search(body)
        if not match:
            continue
        style_ids = [int(value) for value in REF_RE.findall(match.group(1))]
        target = int(match.group(2))
        for style_id in style_ids:
            for linked in descendants(style_id, entities):
                if linked in colors:
                    target_colors[target].add(tuple(round(value, 5) for value in colors[linked]))

    signatures: list[frozenset[tuple[float, float, float]]] = []
    for solid_id in solid_ids:
        geometry = descendants(solid_id, entities)
        associated: set[tuple[float, float, float]] = set()
        for target, linked_colors in target_colors.items():
            if target in geometry:
                associated.update(linked_colors)
        if not associated:
            return False
        signatures.append(frozenset(associated))
    return len(set(signatures)) == 6 and len(set().union(*signatures)) >= 6


def parse_bbox_lines(text: str, label: str) -> list[tuple[float, ...]]:
    pattern = re.compile(
        rf"(?im)^\s*{label}\s*[:=]\s*((?:{NUMBER})(?:\s*[,\s]\s*(?:{NUMBER})){{5}})\s*$"
    )
    rows = []
    for match in pattern.finditer(text):
        values = tuple(float(value) for value in re.findall(NUMBER, match.group(1)))
        if len(values) == 6 and all(math.isfinite(value) for value in values):
            rows.append(values)
    return rows


def check_report(path: Path, solids) -> bool:
    if not path.is_file() or not 0 < path.stat().st_size <= 100_000:
        return False
    text = path.read_text(encoding="utf-8", errors="strict")
    if not re.search(r"(?im)^\s*(?:solid|part)[ _-]?count\s*[:=]\s*6\s*$", text):
        return False
    if not re.search(r"(?im)^\s*units?\s*[:=]\s*(?:millimet(?:er|re)s?|mm)\s*$", text):
        return False
    if not re.search(r"(?im)^\s*(?:step[ _-]?)?schema\s*[:=]\s*AP242\s*$", text):
        return False

    reported = parse_bbox_lines(text, r"part[_ -]?\d+(?:[_ -]?bbox)")
    actual = [bbox_tuple(solid) for solid in solids]
    if len(reported) != 6:
        return False
    unmatched = list(actual)
    for row in reported:
        match = next((box for box in unmatched if close_tuple(row, box, 0.1)), None)
        if match is None:
            return False
        unmatched.remove(match)
    if unmatched:
        return False
    assembly = parse_bbox_lines(text, r"assembly[_ -]?bbox")
    return len(assembly) == 1 and close_tuple(assembly[0], ASSEMBLY_BBOX, 0.1)


def evaluate() -> bool:
    step_path = OUTPUT_ROOT / STEP_NAME
    report_path = OUTPUT_ROOT / REPORT_NAME
    entities, header = parse_part21(step_path)
    if (
        not check_schema(header)
        or not check_references(entities)
        or not check_millimeter_contexts(entities)
    ):
        return False
    solid_ids = {
        entity_id
        for entity_id, body in entities.items()
        if has_type(body, "MANIFOLD_SOLID_BREP")
    }
    if not check_assembly(entities, solid_ids) or not check_colors(entities, solid_ids):
        return False
    solids = load_solids(step_path)
    return check_geometry(solids) and check_report(report_path, solids)


if __name__ == "__main__":
    try:
        print(True if evaluate() else False)
    except Exception:
        print(False)