#!/usr/bin/env python3
"""Rebuild a bounded coordination check from unchanged Crown Landmark sources.

Python standard library only. Produces exact 2D SVG diagrams, a planning OBJ,
and machine-readable findings. It does not author or approve an exterior shell.
Run from any directory: python COORDINATION/build_spatial_review.py
"""
from pathlib import Path
import collections
import hashlib
import html
import itertools
import json

HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
SRC = ROOT / 'SOURCES'
EXT = SRC / 'PI-BLD-0001-V01_CrownLandmark_EXT_R06'
INT = SRC / 'PI-BLD-0001-V01_CrownLandmark_INT_R02'
TARGETS = EXT / '05_ScaleAndPlan/PI-BLD-0001-V01_CrownLandmark_EXT_R06_DesignTargets.json'
LAYOUT = INT / '06_Handoff/EditableLayout/INTERIOR_LAYOUT.json'
OUT = HERE / 'SPATIAL_REVIEW'
OUT.mkdir(exist_ok=True)
ext = json.loads(TARGETS.read_text())
layout = json.loads(LAYOUT.read_text())
rooms = {r['room_id']: r for r in layout['rooms']}
levels = sorted(set(r['level_id'] for r in rooms.values()))
overlaps = []
for r, s in itertools.combinations(rooms.values(), 2):
    if r['level_id'] != s['level_id']:
        continue
    dx = min(r['x_m']+r['width_m'], s['x_m']+s['width_m']) - max(r['x_m'], s['x_m'])
    dy = min(r['y_m']+r['depth_m'], s['y_m']+s['depth_m']) - max(r['y_m'], s['y_m'])
    if dx > 1e-7 and dy > 1e-7:
        overlaps.append({'room_a':r['room_id'], 'room_b':s['room_id'], 'area_m2':dx*dy})

def on_boundary(d, r):
    x, y, width = d['x_m'], d['y_m'], d['clear_width_m']
    x0, y0 = r['x_m'], r['y_m']
    x1, y1 = x0+r['width_m'], y0+r['depth_m']
    eps = 1e-6
    if d['axis'] == 'x':
        return (abs(y-y0)<eps or abs(y-y1)<eps) and x-width/2 >= x0-eps and x+width/2 <= x1+eps
    if d['axis'] == 'y':
        return (abs(x-x0)<eps or abs(x-x1)<eps) and y-width/2 >= y0-eps and y+width/2 <= y1+eps
    return False

boundary_flags, external_endpoints, unknown_endpoints = [], [], []
for d in layout['doors']:
    for end in ['from_room','to_room']:
        room = rooms.get(d[end])
        if room is None:
            rec = {'door_id':d['door_id'], 'endpoint':d[end]}
            (external_endpoints if d[end] in {'EXTERIOR','PODIUM_BACK_OF_HOUSE'} else unknown_endpoints).append(rec)
        elif room['level_id'] != d['level_id'] or not on_boundary(d, room):
            boundary_flags.append({'door_id':d['door_id'], 'endpoint':d[end]})

level_results = []
for lv in levels:
    rs = [r for r in rooms.values() if r['level_id'] == lv]
    x0, x1 = min(r['x_m'] for r in rs), max(r['x_m']+r['width_m'] for r in rs)
    y0, y1 = min(r['y_m'] for r in rs), max(r['y_m']+r['depth_m'] for r in rs)
    level_results.append({'level_id':lv, 'z_m':rs[0]['z_m'], 'zone_count':len(rs),
      'bounds_xy_m':[x0,y0,x1,y1], 'bounding_size_m':[x1-x0,y1-y0],
      'status':'derived_from_proposed_source_layout', 'shell_fit':'not_tested_no_accepted_shell'})

checks = {
 'asset_id':layout['asset_id'], 'review_revision':'R01',
 'scope':'Bounded source-coordinate preflight; no shell, furnished or engine acceptance',
 'sources':[{'path':str(p.relative_to(ROOT)), 'sha256':hashlib.sha256(p.read_bytes()).hexdigest()} for p in [TARGETS,LAYOUT]],
 'counts':{'rooms':len(rooms), 'source_room_records':len(layout['rooms']), 'doors':len(layout['doors']), 'unique_door_ids':len(set(d['door_id'] for d in layout['doors']))},
 'positive_area_room_zone_overlaps':overlaps,
 'door_boundary_flags':boundary_flags, 'unknown_door_endpoints':unknown_endpoints,
 'declared_external_endpoints':external_endpoints, 'levels':level_results,
 'limits':[
  'No positive-area overlap and valid opening endpoints do not prove route accessibility or building-code compliance.',
  'Room boxes are source planning zones; wall assemblies, structure, furniture and player/camera clearance are not verified.',
  'Only the +54 m tower-base envelope is specified; drawing it at upper levels is a comparison, not an upper-floor shell.',
  'The model is a review rig of floor zones and named target outlines. No upper facade, rib curve, wall thickness or collision is invented.',
  'Final district position, north/entrance azimuth and world transform remain null.'
 ]
}
(OUT/'SPATIAL_PREFLIGHT.json').write_text(json.dumps(checks,indent=2)+'\n')

# OBJ surfaces are exact zero-thickness planning zones. Guide outlines are OBJ lines.
obj = ['# CROWN LANDMARK COORDINATION RIG R01', '# metres; X right, Y rear, Z up; front=-Y',
       '# NOT AN EXTERIOR SHELL OR GAME ASSET; zero-thickness proposed floor zones only.']
vertex_count = 0
def poly(name, points, face=False):
    global vertex_count
    obj.append('o '+name)
    for x,y,z in points: obj.append(f'v {x:.6f} {y:.6f} {z:.6f}')
    ids = [str(vertex_count+i+1) for i in range(len(points))]
    obj.append(('f ' if face else 'l ')+' '.join(ids if face else ids+[ids[0]]))
    vertex_count += len(points)
for r in rooms.values():
    x,y,z,w,d = r['x_m'],r['y_m'],r['z_m'],r['width_m'],r['depth_m']
    poly(r['room_id']+'_PROPOSED_FLOOR_ZONE',[(x,y,z),(x+w,y,z),(x+w,y+d,z),(x,y+d,z)],True)
guides = [(0,ext['foundation_footprint_m']['width'],ext['foundation_footprint_m']['depth'],'FOUNDATION')]
guides += [(p['z_m'],p['width_m'],p['depth_m'],'PODIUM') for p in ext['podium_decks']]
guides += [(54,*ext['tower_base_envelope_m'],'TOWER_BASE_ONLY')]
for z,w,d,name in guides:
    poly(f'{name}_Z{z}_TARGET_OUTLINE',[(-w/2,-d/2,z),(w/2,-d/2,z),(w/2,d/2,z),(-w/2,d/2,z)])
(OUT/'CrownLandmark_COORD_R01_ReviewRig.obj').write_text('\n'.join(obj)+'\n')

def svg_plan(lv):
    result = next(r for r in level_results if r['level_id']==lv)
    rs = [r for r in rooms.values() if r['level_id']==lv]
    width,height = 1200,950
    scale = 9
    def xy(x,y): return 450+x*scale, 460-y*scale
    def rect(x,y,w,d,attrs):
        px,py=xy(x,y+d)
        return f'<rect x="{px}" y="{py}" width="{w*scale}" height="{d*scale}" {attrs}/>'
    text = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">',
      '<rect width="1200" height="950" fill="#101c27"/>',
      '<style>text{font-family:Arial,sans-serif;fill:#eff5f6}.small{font-size:15px}.muted{fill:#a6b7c5}</style>',
      '<text x="56" y="54" font-size="15" fill="#ddba72">LOST SOULS / CROWN KEY / COORDINATION R01</text>',
      f'<text x="56" y="98" font-size="32">{lv} · {result["z_m"]:g} m · planning-zone review</text>',
      '<text x="56" y="129" class="small muted">Proposed source coordinates. Upper shell fit remains unverified.</text>']
    # Comparison only. This footprint exists at z=54, not at the displayed level.
    bw,bd=ext['tower_base_envelope_m']
    text.append(rect(-bw/2,-bd/2,bw,bd,'fill="none" stroke="#e0b561" stroke-width="2" stroke-dasharray="8 6"'))
    colors={'core':'#405575','service':'#665d46','public':'#275865','controlled':'#4c507b','private':'#4c507b'}
    for r in rs:
        text.append(rect(r['x_m'],r['y_m'],r['width_m'],r['depth_m'],f'fill="{colors.get(r["access"],"#37516b")}" stroke="#b1c4cd" stroke-width="1"'))
        px,py=xy(r['x_m']+r['width_m']/2,r['y_m']+r['depth_m']/2)
        label=r['room_id'].split('-')[1]
        text.append(f'<text x="{px}" y="{py+4}" text-anchor="middle" font-size="11">{label}</text>')
    for d in layout['doors']:
        if d['level_id']!=lv:continue
        w=d['clear_width_m'];x,y=d['x_m'],d['y_m']
        a,b=(xy(x-w/2,y),xy(x+w/2,y)) if d['axis']=='x' else (xy(x,y-w/2),xy(x,y+w/2))
        text.append(f'<line x1="{a[0]}" y1="{a[1]}" x2="{b[0]}" y2="{b[1]}" stroke="#f5cb74" stroke-width="4"/>')
    x0,y0,x1,y1=result['bounds_xy_m']
    preflight_line = ('Preflight: no overlapping room-zone areas; opening endpoints align.'
      if not overlaps and not boundary_flags and not unknown_endpoints
      else f'Preflight flags: {len(overlaps)} overlaps; {len(boundary_flags)} boundary issues; {len(unknown_endpoints)} unknown endpoints.')
    text += [f'<text x="785" y="190" font-size="21">{x1-x0:g} × {y1-y0:g} m zone bounds</text>',
      f'<text x="785" y="220" class="small muted">X {x0:g} to {x1:g} · Y {y0:g} to {y1:g}</text>',
      '<text x="785" y="260" class="small">Gold dash: 68 × 54 m BASE</text>',
      '<text x="785" y="284" class="small">at +54 m, for comparison only.</text>',
      '<text x="785" y="324" class="small">Actual upper facade, taper,</text>',
      '<text x="785" y="348" class="small">wall thickness and rib intrusion</text>',
      '<text x="785" y="372" class="small">must be supplied and reviewed.</text>',
      '<text x="785" y="422" class="small">Gold gaps: proposed openings.</text>',
      '<text x="785" y="446" class="small">Room IDs match the source plans.</text>',
      '<text x="785" y="496" class="small">+Y = local rear, not north.</text>',
      '<text x="785" y="520" class="small">Front = −Y. No site transform.</text>',
      f'<text x="56" y="845" font-size="19">{preflight_line}</text>',
      '<text x="56" y="875" class="small muted">These checks cover 2D source geometry only. They do not verify a shell, furniture clearance or runtime movement.</text>',
      '<text x="56" y="910" class="small muted">Source: INT R01 technical layout retained in INT R02. Current acceptance protocol: Building R05.</text>', '</svg>']
    (OUT/f'{lv}_Fit_Review.svg').write_text('\n'.join(text))
for lv in ['L25','L26']:svg_plan(lv)
print(json.dumps({'room_zones':len(rooms),'door_records':len(layout['doors']),
 'overlaps':len(overlaps),'door_boundary_flags':len(boundary_flags),'unknown_endpoints':len(unknown_endpoints),
 'outputs':str(OUT)},indent=2))
