from __future__ import annotations

import os
import struct
from pathlib import Path


OUTPUT_ROOT = Path(os.environ.get("EVAL_OUTPUT_ROOT", "/home/user/Desktop"))
OUTPUT_NAME = "task-038_output.stl"
RIB_CENTERS_X = [-40.0, -20.0, 0.0, 20.0, 40.0]
EXPECTED_BOUNDS = [[-50.0, -30.0, 0.0], [50.0, 30.0, 40.0]]
EXPECTED_VOLUME_MM3 = 52488.706
GEOMETRY_TOL = 0.2


def _parse_stl(path: Path):
    data = path.read_bytes()
    triangles = []
    if len(data) >= 84:
        count = struct.unpack("<I", data[80:84])[0]
        if 84 + count * 50 == len(data):
            for index in range(count):
                values = struct.unpack("<12fH", data[84 + index * 50 : 134 + index * 50])
                coordinates = values[3:12]
                triangles.append(
                    tuple(
                        (coordinates[offset], coordinates[offset + 1], coordinates[offset + 2])
                        for offset in range(0, 9, 3)
                    )
                )
            return triangles
    vertices = []
    for raw_line in data.decode("utf-8", errors="ignore").splitlines():
        parts = raw_line.strip().split()
        if len(parts) == 4 and parts[0].lower() == "vertex":
            vertices.append(tuple(float(value) for value in parts[1:]))
            if len(vertices) == 3:
                triangles.append(tuple(vertices))
                vertices = []
    return triangles


def _vertex_key(point):
    return tuple(round(float(value), 4) for value in point)


class Mesh:
    def __init__(self, triangles):
        self.triangles = triangles
        unique = {}
        for triangle in triangles:
            for point in triangle:
                unique[_vertex_key(point)] = tuple(float(value) for value in point)
        self.vertices = list(unique.values())
        self.mins = [min(point[axis] for point in self.vertices) for axis in range(3)]
        self.maxs = [max(point[axis] for point in self.vertices) for axis in range(3)]


def _close(actual, expected, tolerance=GEOMETRY_TOL):
    return abs(float(actual) - float(expected)) <= tolerance


def _near_vertex(mesh: Mesh, target, tolerance=GEOMETRY_TOL):
    return any(
        all(abs(point[axis] - target[axis]) <= tolerance for axis in range(3))
        for point in mesh.vertices
    )


def _cross(first, second):
    return (
        first[1] * second[2] - first[2] * second[1],
        first[2] * second[0] - first[0] * second[2],
        first[0] * second[1] - first[1] * second[0],
    )


def _signed_volume(mesh: Mesh):
    total = 0.0
    for a, b, c in mesh.triangles:
        cross = _cross(b, c)
        total += a[0] * cross[0] + a[1] * cross[1] + a[2] * cross[2]
    return total / 6.0


def _topology_ok(mesh: Mesh):
    vertex_ids = {}
    indexed_faces = []
    for triangle in mesh.triangles:
        face = []
        for point in triangle:
            key = _vertex_key(point)
            if key not in vertex_ids:
                vertex_ids[key] = len(vertex_ids)
            face.append(vertex_ids[key])
        if len(set(face)) != 3:
            return False
        indexed_faces.append(face)

    parent = list(range(len(indexed_faces)))

    def find(item):
        while parent[item] != item:
            parent[item] = parent[parent[item]]
            item = parent[item]
        return item

    def union(first, second):
        root_first, root_second = find(first), find(second)
        if root_first != root_second:
            parent[root_second] = root_first

    edge_owners = {}
    for face_index, (a, b, c) in enumerate(indexed_faces):
        for edge in ((a, b), (b, c), (c, a)):
            key = tuple(sorted(edge))
            edge_owners.setdefault(key, []).append(face_index)
    if any(len(owners) != 2 for owners in edge_owners.values()):
        return False
    for owners in edge_owners.values():
        union(owners[0], owners[1])
    return len({find(index) for index in range(len(indexed_faces))}) == 1


def _ray_hit_x(y, z, triangle):
    a, b, c = triangle
    v0 = (c[1] - a[1], c[2] - a[2])
    v1 = (b[1] - a[1], b[2] - a[2])
    v2 = (y - a[1], z - a[2])
    denominator = v0[0] * v1[1] - v1[0] * v0[1]
    if abs(denominator) < 1e-10:
        return None
    u = (v2[0] * v1[1] - v1[0] * v2[1]) / denominator
    v = (v0[0] * v2[1] - v2[0] * v0[1]) / denominator
    if u < -1e-9 or v < -1e-9 or u + v > 1.0 + 1e-9:
        return None
    return a[0] + u * (c[0] - a[0]) + v * (b[0] - a[0])


def _point_inside(mesh: Mesh, point):
    x, y, z = point
    hits = []
    for triangle in mesh.triangles:
        hit = _ray_hit_x(y, z, triangle)
        if hit is None or hit <= x + 1e-7:
            continue
        if all(abs(hit - previous) > 1e-6 for previous in hits):
            hits.append(hit)
    return len(hits) % 2 == 1


def _rib_ok(mesh: Mesh, center_x):
    x_bounds = [center_x - 1.5, center_x + 1.5]
    visible_triangle_points = [
        (0.875, 5.0),
        (25.0, 5.0),
        (25.0, 32.5714286),
    ]
    if not all(
        _near_vertex(mesh, (x, y, z))
        for x in x_bounds
        for y, z in visible_triangle_points
    ):
        return False

    for y in (5.0, 15.0, 24.0):
        slope_top_z = 4.0 + (32.0 / 28.0) * y
        for x_offset in (-1.4, 0.0, 1.4):
            if not _point_inside(mesh, (center_x + x_offset, y, slope_top_z - 0.3)):
                return False
        if _point_inside(mesh, (center_x, y, slope_top_z + 0.3)):
            return False

    thickness_outside_probes = [
        (center_x - 1.7, 10.0, 10.0),
        (center_x + 1.7, 10.0, 10.0),
    ]
    return not any(_point_inside(mesh, probe) for probe in thickness_outside_probes)


def evaluate() -> bool:
    path = OUTPUT_ROOT / OUTPUT_NAME
    if not path.is_file() or path.stat().st_size <= 0:
        return False
    triangles = _parse_stl(path)
    if len(triangles) < 40:
        return False
    mesh = Mesh(triangles)
    if len(mesh.vertices) < 24:
        return False
    if any(
        not _close(mesh.mins[axis], EXPECTED_BOUNDS[0][axis])
        or not _close(mesh.maxs[axis], EXPECTED_BOUNDS[1][axis])
        for axis in range(3)
    ):
        return False
    if not _topology_ok(mesh):
        return False
    if abs(abs(_signed_volume(mesh)) - EXPECTED_VOLUME_MM3) > 8.0:
        return False
    bracket_solid_probes = [
        (0.0, 0.0, 2.5),
        (0.0, 27.5, 20.0),
        (-49.0, 0.0, 2.5),
        (49.0, 27.5, 20.0),
    ]
    if not all(_point_inside(mesh, probe) for probe in bracket_solid_probes):
        return False
    return all(_rib_ok(mesh, center_x) for center_x in RIB_CENTERS_X)


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