#!/usr/bin/env python3
import filecmp
import os
import re
from pathlib import Path

DESKTOP = Path(os.environ.get("ENGIWORLD_DESKTOP", "C:/Users/user/Desktop"))
SPEC = {'products': [{'class': 'IfcSpace', 'name': 'MAIL-PARCEL-LOBBY', 'storey': 'Ground Floor', 'tokens': ['MAIL PARCEL', 'RESIDENT ACCESS', 'GROUND FLOOR', 'OPERATIONS'], 'predefined': 'INTERNAL'}, {'class': 'IfcSpace', 'name': 'REFUSE-STORE', 'storey': 'Ground Floor', 'tokens': ['REFUSE STORE', 'SEPARATED', 'SERVICE', 'GROUND FLOOR'], 'predefined': 'INTERNAL'}, {'class': 'IfcDoor', 'name': 'MAIL-LOBBY-DOOR', 'storey': 'Ground Floor', 'tokens': ['MAIL PARCEL', 'RESIDENT', 'ACCESS', 'DOOR'], 'predefined': 'DOOR'}, {'class': 'IfcDoor', 'name': 'REFUSE-STORE-DOOR', 'storey': 'Ground Floor', 'tokens': ['REFUSE STORE', 'SERVICE', 'SEPARATED', 'DOOR'], 'predefined': 'DOOR'}], 'annotations': [{'class': 'IfcSpace', 'name': 'APT-101-LIVING', 'tokens': ['RESIDENT ACCESS', 'MAIL ROUTE', 'GROUND FLOOR']}, {'class': 'IfcSpace', 'name': 'APT-201-LIVING', 'tokens': ['RESIDENT ACCESS', 'UPPER UNIT', 'PROTECTED APARTMENT']}]}

DIRECT_IFC_TOOLS = ("ifcopenshell", "xbim", "bcfier", "ifcpatch", "ifcconvert", "ifccsv", "ifcclash")
DIRECT_WRITE_TOKENS = ("result.ifc", "desktop\\result.ifc", "desktop/result.ifc")
ALLOWED_TOOL_TOKENS = (
    "ifccommandserverapp", "ifccommandserver", "graphisoft", "archicad", "/jemi",
    "model.loadfile", "model.savefile", "model.mergefile", "entity.create",
    "entity.get", "entity.delete", "api.executeaddoncommand",
)


def finish(ok):
    print("True" if ok else "False")
    raise SystemExit(0)


def text_norm(value):
    return re.sub(r"[^A-Z0-9]+", " ", str(value or "").upper()).strip()


def same_name(a, b):
    return text_norm(a) == text_norm(b)


def read_text_safe(path, limit=None):
    try:
        data = path.read_bytes()
    except Exception:
        return ""
    if limit is not None:
        data = data[:limit]
    return data.decode("utf-8", errors="ignore")


def history_paths(root):
    home = Path.home()
    return [
        home / ".bash_history",
        home / ".zsh_history",
        home / ".python_history",
        home / ".local/share/fish/fish_history",
        home / "AppData/Roaming/Microsoft/Windows/PowerShell/PSReadLine/ConsoleHost_history.txt",
        home / "AppData/Roaming/Microsoft/Windows/PowerShell/PSReadLine/Visual Studio Code Host_history.txt",
        root / ".bash_history",
        root / ".zsh_history",
    ]


def history_contains_bypass(root):
    for path in history_paths(root):
        if not path.is_file():
            continue
        text = read_text_safe(path).lower()
        for raw_line in text.splitlines():
            line = raw_line.strip()
            if not line or "eval.py" in line:
                continue
            touches_result = any(token in line for token in DIRECT_WRITE_TOKENS)
            uses_direct_tool = any(token in line for token in DIRECT_IFC_TOOLS)
            direct_copy = "copy-item" in line or re.search(r"\b(copy|cp)\b.*init\.ifc.*result\.ifc", line)
            writes_file = any(token in line for token in (">", "tee ", "out-file", "set-content", ".write(", "write_text"))
            allowed = any(token in line for token in ALLOWED_TOOL_TOKENS)
            if touches_result and uses_direct_tool:
                return True
            if touches_result and direct_copy:
                return True
            if touches_result and writes_file and not allowed:
                return True
    return False


def header_looks_graphisoft_edm(path):
    text = read_text_safe(path, 7000).lower()
    compact = text.replace(" ", "")
    return "express data manager" in text and "file_schema(('ifc4'))" in compact


def unique_global_ids(model):
    gids = [e.GlobalId for e in model.by_type("IfcRoot") if getattr(e, "GlobalId", None)]
    return bool(gids) and len(gids) == len(set(gids))


def objects_by_name(model, cls, name):
    return [e for e in model.by_type(cls) if same_name(getattr(e, "Name", ""), name)]


def parent_storey(obj, model):
    for rel in getattr(obj, "ContainedInStructure", None) or []:
        parent = getattr(rel, "RelatingStructure", None)
        if parent and parent.is_a("IfcBuildingStorey"):
            return parent
    for rel in getattr(obj, "Decomposes", None) or []:
        parent = getattr(rel, "RelatingObject", None)
        if parent and parent.is_a("IfcBuildingStorey"):
            return parent
    for rel in model.by_type("IfcRelContainedInSpatialStructure"):
        parent = getattr(rel, "RelatingStructure", None)
        if parent and parent.is_a("IfcBuildingStorey") and obj in (getattr(rel, "RelatedElements", None) or []):
            return parent
    for rel in model.by_type("IfcRelAggregates"):
        parent = getattr(rel, "RelatingObject", None)
        if parent and parent.is_a("IfcBuildingStorey") and obj in (getattr(rel, "RelatedObjects", None) or []):
            return parent
    return None


def related_psets(obj, model):
    psets = []
    seen = set()
    def add(pset):
        if pset and pset.is_a("IfcPropertySet") and pset.id() not in seen:
            seen.add(pset.id())
            psets.append(pset)
    for rel in getattr(obj, "IsDefinedBy", None) or []:
        add(getattr(rel, "RelatingPropertyDefinition", None))
    for rel in model.by_type("IfcRelDefinesByProperties"):
        if obj in (getattr(rel, "RelatedObjects", None) or []):
            add(getattr(rel, "RelatingPropertyDefinition", None))
    return psets


def value_text(value):
    if value is None:
        return ""
    wrapped = getattr(value, "wrappedValue", None)
    if wrapped is not None:
        return str(wrapped)
    return str(value)


def object_search_text(obj, model):
    parts = [getattr(obj, attr, "") for attr in ("Name", "LongName", "ObjectType", "Description", "Tag", "PredefinedType")]
    for pset in related_psets(obj, model):
        parts.append(getattr(pset, "Name", ""))
        for prop in getattr(pset, "HasProperties", None) or []:
            parts.append(getattr(prop, "Name", ""))
            parts.append(value_text(getattr(prop, "NominalValue", None)))
    return text_norm(" ".join(str(p) for p in parts if p is not None))


def has_tokens(obj, model, tokens):
    haystack = object_search_text(obj, model)
    return all(text_norm(token) in haystack for token in tokens)


def ifc_bbox(model):
    try:
        import numpy as np
        import ifcopenshell.geom
    except Exception:
        return None
    settings = ifcopenshell.geom.settings()
    try:
        settings.set(settings.USE_WORLD_COORDS, True)
    except Exception:
        pass
    mins = None
    maxs = None
    for product in model.by_type("IfcProduct"):
        if product.is_a("IfcOpeningElement") or not getattr(product, "Representation", None):
            continue
        try:
            shape = ifcopenshell.geom.create_shape(settings, product)
            verts = np.array(shape.geometry.verts, dtype=float).reshape(-1, 3)
        except Exception:
            continue
        if verts.size == 0:
            continue
        pmin = verts.min(axis=0)
        pmax = verts.max(axis=0)
        mins = pmin if mins is None else np.minimum(mins, pmin)
        maxs = pmax if maxs is None else np.maximum(maxs, pmax)
    if mins is None or maxs is None:
        return None
    return mins.tolist(), maxs.tolist()


def bbox_preserved(init_model, result_model, tol=0.75):
    init_bbox = ifc_bbox(init_model)
    result_bbox = ifc_bbox(result_model)
    if init_bbox is None or result_bbox is None:
        return True
    for a, b in zip(init_bbox[0] + init_bbox[1], result_bbox[0] + result_bbox[1]):
        if abs(float(a) - float(b)) > tol:
            return False
    return True


def check_baseline(init_model, result_model):
    for cls in ("IfcBuildingStorey", "IfcSpace"):
        init_names = {text_norm(getattr(e, "Name", "")) for e in init_model.by_type(cls)}
        result_names = {text_norm(getattr(e, "Name", "")) for e in result_model.by_type(cls)}
        if not init_names.issubset(result_names):
            return False
    for cls in ("IfcWall", "IfcSlab", "IfcRoof", "IfcDoor", "IfcWindow", "IfcStair", "IfcColumn"):
        if len(result_model.by_type(cls)) < len(init_model.by_type(cls)):
            return False
    return bbox_preserved(init_model, result_model)


def check_required_products(init_model, result_model):
    increases = {}
    for item in SPEC.get("products", []):
        increases[item["class"]] = increases.get(item["class"], 0) + 1
        matches = objects_by_name(result_model, item["class"], item["name"])
        if not matches:
            return False
        obj = matches[0]
        if item.get("storey"):
            storey = parent_storey(obj, result_model)
            if storey is None or not same_name(getattr(storey, "Name", ""), item["storey"]):
                return False
        predefined = item.get("predefined")
        if predefined and hasattr(obj, "PredefinedType") and text_norm(getattr(obj, "PredefinedType", "")) != text_norm(predefined):
            return False
        if item.get("tokens") and not has_tokens(obj, result_model, item["tokens"]):
            return False
    for cls, inc in increases.items():
        if len(result_model.by_type(cls)) - len(init_model.by_type(cls)) < inc:
            return False
    return True


def check_annotations(result_model):
    for item in SPEC.get("annotations", []):
        matches = objects_by_name(result_model, item["class"], item["name"])
        if not matches:
            return False
        if not any(has_tokens(obj, result_model, item.get("tokens", [])) for obj in matches):
            return False
    return True


def check_model(init_path, result_path):
    import ifcopenshell

    result_model = ifcopenshell.open(str(result_path))
    if not str(getattr(result_model, "schema", "")).upper().startswith("IFC4"):
        return False
    if not unique_global_ids(result_model):
        return False
    if len(result_model.by_type("IfcBuildingElementProxy")) != 0:
        return False
    init_model = ifcopenshell.open(str(init_path)) if init_path.is_file() else None
    if init_model is not None:
        if not check_baseline(init_model, result_model):
            return False
        if not check_required_products(init_model, result_model):
            return False
    if not check_annotations(result_model):
        return False
    return True


def evaluate(root):
    root = Path(root)
    result = root / "result.ifc"
    init = root / "init.ifc"
    if not result.is_file() or result.stat().st_size < 6000:
        return False
    if init.is_file() and filecmp.cmp(str(init), str(result), shallow=False):
        return False
    if history_contains_bypass(root):
        return False
    if not header_looks_graphisoft_edm(result):
        return False
    return check_model(init, result)


if __name__ == "__main__":
    try:
        finish(evaluate(DESKTOP))
    except Exception:
        finish(False)