"""One fresh private V6 writer. Immutable LIVEV5 plus closed INSEE/Berlin only; no publication."""
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path
import copy
import ctypes
import gzip
import hashlib
import json
import os
import re
import shutil
import sqlite3
import sys
import zipfile

ROOT = Path(__file__).resolve().parents[3]
WORK = Path(__file__).parent
BASE = WORK.parent
V4 = BASE / 'public-expansion-v4'
PREVIOUS = BASE / 'public-expansion-v5'
OLD_RELEASE = 'eec8deb71e30555bf4d85c09'
sys.path[:0] = [str(V4), str(ROOT / 'scripts_build')]
from catalog_v4 import Catalog
from public_name_segment_layout import SCHEMA, Segments, View
from public_name_v3_projection import EvidencePages, head, attach_evidence
import build_public_name_directory as helpers

def check(ok, message):
    if not ok:
        raise RuntimeError(message)

def sha(path):
    digest = hashlib.sha256()
    with Path(path).open('rb') as stream:
        for chunk in iter(lambda: stream.read(1024 * 1024), b''):
            digest.update(chunk)
    return digest.hexdigest()

def read(path):
    return json.loads(Path(path).read_text('utf-8'))

def encoded(value):
    return (json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':')) + '\n').encode('utf-8')

def save(path, value):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open('xb') as stream:
        stream.write(encoded(value))

def rows(path):
    with gzip.open(path, 'rt', encoding='utf-8') as stream:
        for line in stream:
            check(len(line.encode('utf-8')) <= 65536, 'Official packet row exceeds fixed bound')
            yield json.loads(line)

def pin(path):
    return {'path': Path(path).relative_to(ROOT).as_posix(), 'bytes': Path(path).stat().st_size, 'sha256': sha(path)}

def report(label, **fields):
    print(json.dumps({'stage': label, 'at': datetime.now(timezone.utc).isoformat(), **fields}), flush=True)

from source_conditions_02 import SPECS, event, source_catalog

def catalog(frozen):
    directory = WORK / 'private-catalog'
    directory.mkdir()
    dest = directory / 'catalog.sqlite3'
    check(not dest.exists(), 'Fresh catalog required')
    check(not (PREVIOUS / 'private-catalog/catalog.sqlite3-wal').exists() or
          (PREVIOUS / 'private-catalog/catalog.sqlite3-wal').stat().st_size == 0, 'Original closed catalog has uncheckpointed WAL')
    shutil.copyfile(PREVIOUS / 'private-catalog/catalog.sqlite3', dest)
    check(sha(dest) == next(x['sha256'] for x in frozen['dependencies'] if x['path'].endswith('private-catalog/catalog.sqlite3')),
          'Exact immutable baseline copy differs')
    census = sqlite3.connect(WORK / 'scope-census.sqlite3')
    census.executescript('PRAGMA journal_mode=WAL; PRAGMA cache_size=-32768; CREATE TABLE names(key TEXT PRIMARY KEY,mask INTEGER,prior_mask INTEGER) WITHOUT ROWID;')
    old_pairs = 0
    with gzip.open(PREVIOUS / 'EXPECTED_KEY_ROLES.jsonl.gz', 'rt', encoding='utf-8') as stream:
        for line in stream:
            row = json.loads(line)
            mask = sum({'given': 1, 'family': 2}[r] for r in row['roles'])
            census.execute('INSERT INTO names VALUES(?,?,?)', (row['key'], mask, mask)); old_pairs += mask.bit_count()
    census.commit()
    check(census.execute('SELECT count(*) FROM names').fetchone()[0] == 1848887, 'Prior key export differs')
    c = Catalog(dest)
    policy = helpers.policy()
    for rank, spec in enumerate(SPECS, 11000):
        seen = set(); pairs = set(); counts = Counter(); count = 0
        for row in rows(BASE / spec['folder'] / spec['packet'] / 'NAMES.jsonl.gz'):
            triple = (row['role'], row['key'], row['form'])
            check(triple not in seen, 'Duplicate official literal observation'); seen.add(triple)
            pair = (row['role'], row['key']); pairs.add(pair)
            c.event(row['key'], row['form'], event(row, spec, policy), rank)
            mask = {'given': 1, 'family': 2}[row['role']]
            census.execute('INSERT INTO names VALUES(?,?,0) ON CONFLICT(key) DO UPDATE SET mask=names.mask|excluded.mask', (row['key'], mask))
            count += 1
            if count % 25000 == 0:
                c.db.commit(); census.commit(); report('official_rows', source=spec['id'], rows=count)
        counts.update(role for role, _ in pairs)
        check(count == spec['rows'] and dict(counts) == spec['roles'] and len({k for _, k in pairs}) == spec['keys'], 'Frozen official source census differs')
        c.db.execute('INSERT INTO units VALUES(?,?,?)', (spec['scope'], spec['names_sha256'], count))
        c.db.commit(); census.commit()
    total, given, family, shared, added = census.execute('SELECT count(*),sum((mask&1)>0),sum((mask&2)>0),sum(mask=3),sum(prior_mask=0) FROM names').fetchone()
    check(given + family - shared == total, 'Role union arithmetic differs')
    c.db.execute('CREATE INDEX IF NOT EXISTS events_by_key ON events(key,seq)'); c.db.commit()
    wanted = census.execute('SELECT key,mask FROM names ORDER BY key')
    matched = 0
    with (WORK / 'EXPECTED_KEY_ROLES.jsonl.gz').open('xb') as raw, gzip.GzipFile(filename='', mode='wb', fileobj=raw, mtime=0) as out:
        for key, in c.db.execute('SELECT key FROM names ORDER BY key'):
            roles = [r[0] for r in c.db.execute('SELECT role FROM roles WHERE key=? ORDER BY role', (key,))]
            mask = sum({'given': 1, 'family': 2}[r] for r in roles)
            check(next(wanted, None) == (key, mask), 'Exact independently merged role/key census differs')
            out.write(encoded({'key': key, 'roles': roles})); matched += 1
    check(next(wanted, None) is None and matched == total, 'Exact merged key total differs')
    c.db.execute('PRAGMA wal_checkpoint(TRUNCATE)'); c.close()
    census.execute('PRAGMA wal_checkpoint(TRUNCATE)'); census.close()
    result = {'ok': True, 'closed_at': datetime.now(timezone.utc).isoformat(), 'input_manifest_sha256': sha(WORK / 'INPUT_MANIFEST_02.json'),
              'baseline_keys': 1848887, 'keys': total, 'given_role_keys': given, 'family_role_keys': family,
              'shared_role_keys': shared, 'additional_public_keys': added, 'prior_role_pairs_preserved': old_pairs,
              'catalog_sha256': sha(dest), 'key_role_index_sha256': sha(WORK / 'EXPECTED_KEY_ROLES.jsonl.gz'),
              'all_native_official_source_role_form_counts_exact': True, 'no_collected_union_increment': True}
    check(result['key_role_index_sha256'] == sha(WORK / 'FROZEN_EXPECTED_KEY_ROLES_02.jsonl.gz'), 'Catalog differs from pre-writer frozen exact expected role union')
    expected = read(WORK / 'EXPECTED_SCOPE_02.json')
    check(all(result[k] == expected[k] for k in ['keys','given_role_keys','family_role_keys','shared_role_keys','additional_public_keys']), 'Catalog census differs from frozen expected scope')
    save(WORK / 'CATALOG_CLOSED_RECEIPT.json', result)
    report('catalog_closed', **result)
    return result

def build(closed):
    old = read(ROOT / f'site/assets/public-name-data/{OLD_RELEASE}/manifest.json')
    code = {str(p.relative_to(ROOT)): sha(p) for p in [Path(__file__), V4 / 'catalog_v4.py',
            ROOT / 'scripts_build/public_name_v3_catalog.py', ROOT / 'scripts_build/public_name_v3_projection.py',
            ROOT / 'scripts_build/public_name_segment_layout.py']}
    release = hashlib.sha256(encoded({'schema': SCHEMA, 'inputs': sha(WORK / 'INPUT_MANIFEST_02.json'), 'catalog': closed['catalog_sha256'], 'code': code})).hexdigest()[:24]
    stage = WORK / 'staging' / release
    target = stage / 'assets/public-name-data' / release
    target.mkdir(parents=True)
    projection = sqlite3.connect(WORK / 'projection.sqlite3')
    projection.executescript('PRAGMA cache_size=-32768; CREATE TABLE heads(key TEXT PRIMARY KEY,data TEXT,roles TEXT);')
    evidence = Segments(target, release, segment_bytes=512 * 1024, start_number=500000)
    pages = EvidencePages(evidence, projection)
    c = Catalog(WORK / 'private-catalog/catalog.sqlite3')
    totals = Counter(); languages = Counter(); largest = (0, '')
    for row in c.records():
        totals['spellings'] += 1; totals['role_keys'] += len(row['roles'])
        for role in row['roles']: totals[role + '_role_keys'] += 1
        totals['corroborated_spellings'] += bool(row['corroborated_roles'])
        totals['training_source_spellings'] += bool(row['primary_locators'])
        totals['source_attested_spellings'] += bool(row.get('attestations'))
        totals['training_source_only_spellings'] += bool(row['primary_locators']) and not row['corroborated_roles'] and not row.get('attestations')
        totals['source_role_differences'] += row['source_role_difference']
        for item in row.get('attestations', []):
            if item['tier'] == 'lexical_sharealike': languages[(item['language'], item['language_name'])] += 1
        largest = max(largest, (len(encoded(row)), row['key']))
        compact = head(row, pages.add(row))
        projection.execute('INSERT INTO heads VALUES(?,?,?)', (row['key'], encoded(compact).decode(), json.dumps(row['roles'])))
        if totals['spellings'] % 25000 == 0:
            projection.commit(); report('evidence_projected', keys=totals['spellings'])
    pages.flush(); evidence.close(); projection.commit()
    check(totals['spellings'] == closed['keys'] and totals['given_role_keys'] == closed['given_role_keys'] and
          totals['family_role_keys'] == closed['family_role_keys'] and totals['corroborated_spellings'] == 31818 and
          totals['training_source_spellings'] == 135249 and len({code for code, _ in languages}) == 224, 'Complete source/evidence census differs')
    totals['additional_public_spellings'] = closed['additional_public_keys']
    hot = Segments(target, release, segment_bytes=128 * 1024)
    writers = {role: View(hot, role, target_page_bytes=32 * 1024, page_rows=25) for role in ('all', 'given', 'family')}
    largest_head = (0, '')
    for key, data, roles in projection.execute('SELECT key,data,roles FROM heads ORDER BY key'):
        row = attach_evidence(json.loads(data), projection)
        largest_head = max(largest_head, (len(encoded(row)), key))
        writers['all'].add(row)
        for role in json.loads(roles): writers[role].add(row)
    views = {role: writer.finish() for role, writer in writers.items()}
    hot.close(); projection.close(); c.close()
    sources = source_catalog(old)
    def download(source, filename, label, kind, data):
        check(len(data) <= 25 * 1024 * 1024, 'Actual public asset exceeds fixed cap')
        path = target / 'downloads' / filename
        if path.exists(): check(path.read_bytes() == data, 'Conflicting shared public support filename')
        else:
            path.parent.mkdir(exist_ok=True); path.write_bytes(data)
        source['downloads'].append({'kind': kind, 'label': label, 'original_filename': filename,
                                   'url': f'/assets/public-name-data/{release}/downloads/{filename}', 'bytes': len(data), 'sha256': sha(path)})
    for spec in SPECS:
        source = next(s for s in sources if s['id'] == spec['id'])
        packet = BASE / spec['folder'] / spec['packet']
        prefix = spec['prefix']
        # Exact binary slices reconstruct the original compressed source packet.
        chunks = []
        with (packet / 'NAMES.jsonl.gz').open('rb') as stream:
            for number in range(1000):
                data = stream.read(15 * 1024 * 1024)
                if not data: break
                name = f'{prefix}-names.gz.part{number:03d}'
                download(source, name, f'Original admitted source packet, consecutive binary part {number + 1}', 'source', data)
                chunks.append({'part': number, 'file': name, 'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest()})
        if (packet / 'WITNESSES.jsonl.gz').exists():
            witness_data = (packet / 'WITNESSES.jsonl.gz').read_bytes()
            download(source, prefix + '-WITNESSES.jsonl.gz', 'All admitted cleaned/anonymized source-row observations; counts remain separate', 'source', witness_data)
        chunk_manifest = {'original_filename': 'NAMES.jsonl.gz', 'original_sha256': spec['names_sha256'],
                          'instruction': 'Concatenate binary parts in part order before gzip decompression. These are consecutive byte ranges of ONE gzip file.', 'chunks': chunks}
        download(source, f'{prefix}-parts.json', 'Original packet reconstruction manifest and hashes', 'source', encoded(chunk_manifest))
        metadata = WORK / f'{prefix}-proofs.zip'
        with zipfile.ZipFile(metadata, 'x', compression=zipfile.ZIP_DEFLATED) as bundle:
            for name in ('RECEIPT.json', 'SOURCE.json', 'NOTICE.txt', 'MODIFICATIONS.json', 'COUNTS.json', 'PRIMARY_REUSE_EVIDENCE.json'):
                if (packet / name).exists():
                    info = zipfile.ZipInfo(name, date_time=(2026, 11, 2, 0, 0, 0)); info.compress_type = zipfile.ZIP_DEFLATED
                    bundle.writestr(info, (packet / name).read_bytes())
        download(source, metadata.name, 'Source hashes, original notices, reuse conditions and modification evidence', 'source', metadata.read_bytes())
        download(source, f'{prefix}-NOTICE.txt', 'Publisher attribution, license and modification notice', 'notice', (packet / 'NOTICE.txt').read_bytes())
    cutoff = {'release': release, 'prior_public_release': OLD_RELEASE, 'inputs': SPECS,
              'input_manifest_sha256': sha(WORK / 'INPUT_MANIFEST_02.json'), 'global_collected_increment': 0,
              'official_list_presence_not_independent_corroboration': True,
              'unknown_language_origin_meaning_gender': True, 'INSEE_rare_spellings_and_Berlin_suppressed_or_withdrawn_resources_not_reconstructed': True,
              'original_gzip_packets_reconstructable_from_exact_binary_parts': True}
    for source in sources:
        download(source, 'v6-cutoff.json', 'Frozen V6 source scope and conditions', 'notice', encoded(cutoff))
        download(source, 'build_v6_02.py', 'V6 transformation source', 'modifications', Path(__file__).read_bytes())
        download(source, 'source_conditions_02.py', 'V6 exact source projection and source conditions', 'modifications', (WORK / 'source_conditions_02.py').read_bytes())
    manifest = {**old, 'release': release, 'totals': dict(totals), 'sources': sources, 'views': views,
                'storage': {**old['storage'], 'hot_segments': len(hot.files), 'evidence_segments': len(evidence.files)},
                'lexical_language_attestations': [{'code': code, 'name': name, 'observations': count} for (code, name), count in sorted(languages.items(), key=lambda x: (x[0][1].casefold(), x[0][0]))],
                'limitations': old['limitations'] + ['Insee birth-cohort counts and Berlin published count/position contexts remain separate and are never pooled as people or corpus growth. Source geography and publisher categories do not establish name language, origin, meaning or gender. Official list presence is not identity validation, worldwide frequency or independent corroboration. Suppressed, omitted and withdrawn values are not reconstructed.']}
    check(len(encoded(manifest)) <= 512 * 1024, 'Actual manifest transport cap exceeded')
    (target / 'manifest.json').write_bytes(encoded(manifest))
    (stage / 'assets/public-name-data/manifest.json').write_bytes(encoded(manifest))
    # Reuse the closed upper-index compiler without executing its builder.
    from build_v4 import compile_indexes
    indexes = compile_indexes(views, target, release)
    generated = stage / 'functions/_lib/active-public-name-release.js'
    generated.parent.mkdir(parents=True)
    generated.write_text('const freeze=(v)=>{if(v&&typeof v==="object"){Object.freeze(v);for(const c of Object.values(v))freeze(c);}return v;};\nconst data=freeze(' + json.dumps({'manifest': manifest, 'indexes': indexes}, ensure_ascii=True, separators=(',', ':')) + ');\nexport const activeManifest=data.manifest;\nexport const compiledIndexes=data.indexes;\n', encoding='utf-8')
    retained = [p for p in (ROOT / 'site').rglob('*') if p.is_file() and 'functions' not in p.parts and '.wrangler' not in p.parts]
    fresh = [p for p in (stage / 'assets').rglob('*') if p.is_file()]
    check(len(retained) + len(fresh) - 1 <= 20000 and max(p.stat().st_size for p in fresh) <= 25 * 1024 * 1024, 'Actual retained static-file/asset budget exceeded')
    result = {'ok': True, 'built_at': datetime.now(timezone.utc).isoformat(), 'release': release,
              'stage': str(stage), 'totals': dict(totals), 'views': {r: {'count': v['count'], 'depth': v['depth']} for r, v in views.items()},
              'hot_segments': len(hot.files), 'evidence_segments': len(evidence.files), 'evidence_pages': pages.pages,
              'largest_full_record': largest, 'largest_head': largest_head, 'largest_evidence_page_bytes': pages.largest_inflated,
              'new_static_files': len(fresh), 'total_static_files_including_retained': len(retained) + len(fresh) - 1,
              'maximum_new_asset_bytes': max(p.stat().st_size for p in fresh), 'new_static_bytes': sum(p.stat().st_size for p in fresh),
              'manifest_sha256': sha(target / 'manifest.json'), 'catalog_sha256': sha(WORK / 'private-catalog/catalog.sqlite3'),
              'key_role_index': str(WORK / 'EXPECTED_KEY_ROLES.jsonl.gz'), 'code': code,
              'canonical_site_changed': False, 'deployed': False, 'fifty_million_achieved': False}
    save(WORK / 'BUILD_RECEIPT.json', result)
    report('build_complete', **result)

def main():
    from budget import preflight, start_monitor
    check(Path(sys.executable).resolve() == Path('C:/Users/bhara/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe').resolve(), 'Bundled Python required')
    check((WORK / 'INPUT_MANIFEST_02.json').exists() and (WORK / 'EXPECTED_SCOPE_02.json').exists(), 'Exact source and expected role census must freeze before writer')
    frozen = read(WORK / 'INPUT_MANIFEST_02.json')
    SPECS[:] = frozen['inputs']
    for item in frozen['dependencies'] + frozen['code']:
        path = ROOT / item['path']; check(path.stat().st_size == item['bytes'] and sha(path) == item['sha256'], 'Frozen input/source/code changed before writer')
    resources = preflight()
    kernel = ctypes.WinDLL('kernel32', use_last_error=True)
    kernel.CreateMutexW.restype = ctypes.c_void_p
    kernel.CreateMutexW.argtypes = [ctypes.c_void_p, ctypes.c_bool, ctypes.c_wchar_p]
    handle = kernel.CreateMutexW(None, False, 'Local\\NamesDoneRightPublicV6Writer')
    check(handle, 'Unable to create V6 writer OS mutex')
    kernel.WaitForSingleObject.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
    check(kernel.WaitForSingleObject(handle, 0) == 0, 'Another V6 primary writer owns the OS lease')
    stop = start_monitor()
    try:
        save(WORK / 'RUN_IDENTITY.json', {'pid': os.getpid(), 'started_at': datetime.now(timezone.utc).isoformat(), 'command': str(Path(__file__)), 'mutex': 'Local\\NamesDoneRightPublicV6Writer', 'writer_sha256': sha(__file__), 'resources': resources, 'input_manifest_sha256': sha(WORK / 'INPUT_MANIFEST_02.json'), 'expected_scope_sha256': sha(WORK / 'EXPECTED_SCOPE_02.json')})
        closed = catalog(frozen)
        build(closed)
    finally:
        stop.set()
        kernel.ReleaseMutex.argtypes = [ctypes.c_void_p]; kernel.ReleaseMutex(handle)
        kernel.CloseHandle.argtypes = [ctypes.c_void_p]; kernel.CloseHandle(handle)

if __name__ == '__main__':
    try:
        main()
    except Exception as exc:
        save(WORK / 'FAILED.json', {'at': datetime.now(timezone.utc).isoformat(), 'type': type(exc).__name__, 'error': str(exc), 'writer_sha256': sha(__file__)})
        raise
