"""Auditable auxiliary temporal alignment; original search policy data unchanged.

Auxiliary clips are newly mixed dry recordings with neutral duplicated channels,
NOT rerendered binaural scenes. They teach sound semantics/time, not localization.
Candidate crops are privileged auxiliary inputs only, never policy observations.
"""
import collections
import hashlib
import json
import random
from pathlib import Path


def read(path):
    return [json.loads(line) for line in Path(path).open() if line.strip()]


def sha(path):
    h = hashlib.sha256()
    with Path(path).open('rb') as f:
        for block in iter(lambda: f.read(8 * 1024 * 1024), b''):
            h.update(block)
    return h.hexdigest()


def atomic(path, value):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix('.tmp')
    tmp.write_text(json.dumps(value, indent=2))
    tmp.replace(path)


def active_segment(path):
    import numpy as np
    import soundfile as sf
    from scipy.signal import resample_poly
    import math
    wave, sr = sf.read(path, dtype='float32', always_2d=True)
    assert np.isfinite(wave).all()
    mono = wave.mean(axis=1)
    g = math.gcd(sr, 32000)
    mono = resample_poly(mono, 32000 // g, sr // g).astype('float32')
    hop = 6400
    rms = np.array([np.sqrt(np.mean(mono[i:i+hop] ** 2)) for i in range(0, len(mono)-hop+1, hop)])
    threshold = max(1e-5, float(rms.max()) * 10 ** (-32 / 20)) if len(rms) else 1
    candidates = [i for i in range(max(0, len(rms)-19)) if (rms[i:i+20] > threshold).all()]
    if not candidates:
        raise ValueError('no continuous four-second audible-energy window')
    start = max(candidates, key=lambda i: float(rms[i:i+20].min()))
    x = mono[start*hop:start*hop+128000].copy()
    x *= .12 / max(float(np.sqrt(np.mean(x*x))), 1e-8)
    return x, dict(source_sha256=sha(path), crop_start_s=start*.2,
                   energy_hop_s=.2, relative_threshold_db=-32,
                   minimum_bin_rms=float(rms[start:start+20].min()),
                   audit='automatic energy continuity, not human perceptual certification')


def build(cfg):
    import numpy as np
    import soundfile as sf
    root = Path(cfg['output_root'])/'data'
    root.mkdir(parents=True, exist_ok=True)
    original = Path(cfg['policy_data'])
    source_audit = json.loads((original/'audit.json').read_text())
    assert source_audit['train_validation_test_scene_clip_disjoint']
    proofs, identities, cache = {}, {}, {}
    for split in ['train', 'validation']:
        episodes = read(original/f'{split}_episodes.jsonl')
        assert sha(original/f'{split}_episodes.jsonl') == source_audit['splits'][split]['episodes_sha256']
        assert sha(original/f'{split}.jsonl') == source_audit['splits'][split]['sha256']
        unique = {e['clip_id']: e for e in episodes if e['task'] != 'HOS'}
        identities[split] = {k: {e[k] for e in episodes} for k in ['scene', 'clip_id']}
        rows, rejected, accepted, assets = [], collections.Counter(), [], set()
        for clip, ep in sorted(unique.items()):
            cs = ep['label']['candidates']
            if len(cs) != 2 or cs[0]['noun'] == cs[1]['noun']:
                rejected['ambiguous_same_class'] += 1
                continue
            segments, checks = [], []
            try:
                for c in cs:
                    path = c['dry_audio']
                    if path not in cache:
                        try:
                            cache[path] = active_segment(path)
                        except (OSError, ValueError, AssertionError) as error:
                            cache[path] = str(error)
                    if isinstance(cache[path], str):
                        raise ValueError(cache[path])
                    x, proof = cache[path]
                    segments.append(x)
                    checks.append(proof)
            except (OSError, ValueError, AssertionError):
                rejected['missing_or_noncontinuous_dry_audio'] += 1
                continue
            for order in [0, 1]:
                for longer in [0, 1]:
                    lengths = [4 if i == longer else 2 for i in range(2)]
                    starts = [0., 0.]
                    starts[order] = 1.
                    starts[1-order] = 1. + lengths[order] + 1.
                    mixed = np.zeros(320000, dtype='float32')
                    for i in range(2):
                        part = segments[i][:lengths[i]*32000].copy()
                        fade = np.linspace(0, 1, 640, dtype='float32')
                        part[:640] *= fade
                        part[-640:] *= fade[::-1]
                        mixed[int(starts[i]*32000):int((starts[i]+lengths[i])*32000)] += part
                    mixed *= min(1., .95 / max(float(abs(mixed).max()), 1e-8))
                    wav = root/'audio'/split/f'{clip}_o{order}_l{longer}.wav'
                    wav.parent.mkdir(parents=True, exist_ok=True)
                    sf.write(wav, np.stack([mixed, mixed], axis=1), 32000, subtype='PCM_16')
                    # Verify emitted audio, not just scheduled metadata.
                    actual, sr = sf.read(wav, always_2d=True)
                    energy = np.sqrt(np.mean(actual.reshape(50, 6400, 2)**2, axis=(1, 2)))
                    for i in range(2):
                        bins = energy[int(starts[i]*5):int((starts[i]+lengths[i])*5)]
                        assert (bins > 1e-5).all()
                    active = {b for i in range(2) for b in range(int(starts[i]*5), int((starts[i]+lengths[i])*5))}
                    assert all(energy[b] < 1e-7 for b in range(50) if b not in active)
                    wave_hash = sha(wav)
                    for query, target in [('first', order), ('last', 1-order), ('longer', longer), ('shorter', 1-longer)]:
                        rows.append(dict(id=f'{clip}:o{order}:l{longer}:{query}', clip_id=clip, scene=ep['scene'], split=split,
                            audio_path=str(wav), audio_sha256=wave_hash, panorama=ep['panorama'],
                            candidates=[dict(noun=c['noun'], center=c['center']) for c in cs],
                            query=query, target_index=target, starts=starts, durations=lengths,
                            provenance='constructed dry temporal counterfactual; neutral duplicated stereo; no spatial label'))
            accepted.append(dict(clip_id=clip, source_checks=checks))
            assets.update(c['dry_audio'] for c in cs)
            atomic(root/'build_status.json', dict(split=split, accepted=len(accepted), examined=len(accepted)+sum(rejected.values()), total=len(unique)))
        assert len(accepted) >= (cfg['minimum_alignment_clips'] if split == 'train' else 16), 'Insufficient automatically checked auxiliary audio'
        path = root/f'aux_{split}.jsonl'
        path.write_text(''.join(json.dumps(row)+'\n' for row in rows))
        atomic(root/f'{split}_waveform_audit.json', dict(accepted=accepted,rejected=dict(rejected),human_review=False))
        proofs[split] = dict(rows=len(rows), clips=len(accepted), sha256=sha(path), assets=sorted(assets),rejected=dict(rejected))
    for k in ['scene', 'clip_id']:
        assert not identities['train'][k] & identities['validation'][k]
    atomic(root/'audit.json', dict(phase='complete', auxiliary=proofs,
        train_validation_scene_clip_disjoint=True, policy_audit_sha256=sha(original/'audit.json'),
        shared_dry_assets=len(set(proofs['train']['assets']) & set(proofs['validation']['assets'])),
        caveats=['Auxiliary time windows checked using emitted waveform energy, not human labels.',
                 'Auxiliary neutral stereo does not teach binaural localization.',
                 'Search-policy recordings retain original stereo and existing silver labels.',
                 'Asset/pretraining overlap is not eliminated; scene/clip split is enforced.']))


def auxiliary_batch(row, proc, seed, mode='binding'):
    import torch
    import soundfile as sf
    from training.hvs_audio_fourtask.data import load_image
    from omini.data.staqa_preprocessing import prepare_staqa_waveform
    permutation = [0, 1]
    random.Random(seed).shuffle(permutation)
    question = {'first':'started first', 'last':'started later', 'longer':'lasted longer', 'shorter':'lasted for less time'}[row['query']]
    content, images = [], []
    if mode == 'binding':
        for j, i in enumerate(permutation):
            content += [dict(type='text',text=f'Candidate {"AB"[j]}:'),dict(type='image')]
            images.append(load_image(dict(panorama=row['panorama'], pose=row['candidates'][i]['center'])))
        target = 'AB'[permutation.index(row['target_index'])]
        request = f'Which pictured object made the sound that {question}? Answer only A or B.'
    else:
        target = row['candidates'][row['target_index']]['noun']
        request = f'Name the sound-producing object whose sound {question}. Answer with the object name only.'
    content += [dict(type='text',text='<|audio_start|>'+'<|audio_pad|>'*41+'<|audio_end|>'),dict(type='text',text=request)]
    messages = [dict(role='system',content='Identify objects from audible events. Use the complete recording to compare their timing.'),dict(role='user',content=content)]
    text = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    batch = dict(proc(text=[text], images=images or None, return_tensors='pt'))
    n = batch['input_ids'].shape[1]
    target_ids = torch.tensor([proc.tokenizer.encode(target+'<|im_end|>',add_special_tokens=False)])
    batch['input_ids'] = torch.cat([batch['input_ids'],target_ids],1)
    batch['attention_mask'] = torch.ones_like(batch['input_ids'])
    batch['labels'] = batch['input_ids'].clone()
    batch['labels'][:,:n] = -100
    wave,sr = sf.read(row['audio_path'],dtype='float32',always_2d=True)
    batch['audio'] = prepare_staqa_waveform(wave,sr).unsqueeze(0)
    return batch,n,target