"""Build the legacy family, add a fixed SFT holdout, or export historical arms."""
from __future__ import annotations

import argparse
import hashlib
from collections import Counter, defaultdict
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq

from release_utils import (ROOT, export_rows, load_json, make_manifest, member_record,
                           normalized_prompt, write_json, write_parquet)

SPLIT_SEED = 20260907
CATEGORIES = ['math_number_theory', 'data_structure', 'dynamic_programming', 'greedy_search',
              'implementation_simulation', 'graph', 'other_algorithm']
RAW_TO_FORMAL = {x: x for x in CATEGORIES + ['no_tags']}
RAW_TO_FORMAL.update({x: 'other_algorithm' for x in
                      ['sorting', 'string', 'bit_manipulation', 'recursion_backtracking', 'geometry', 'other_tagged']})


def formal(value):
    return RAW_TO_FORMAL.get(value, 'other_algorithm') if value else 'no_tags'


def choose_validation(rows, count=100):
    """Largest-remainder source/category allocation, hash-ranked unique prompts."""
    multiplicity = Counter(normalized_prompt(r['prompt']) for r in rows)
    strata = defaultdict(list)
    full_counts = Counter((r['dataset'], r['primary_category']) for r in rows)
    for row in rows:
        if multiplicity[normalized_prompt(row['prompt'])] == 1:
            strata[row['dataset'], row['primary_category']].append(row)
    quotas = {key: count * n // len(rows) for key, n in full_counts.items()}
    remaining = count - sum(quotas.values())
    order = sorted(full_counts, key=lambda key: (-(count * full_counts[key] % len(rows)), key))
    for key in order[:remaining]:
        quotas[key] += 1
    selected = []
    for key in sorted(quotas):
        if len(strata[key]) < quotas[key]:
            raise ValueError(f'Insufficient unique prompts for stratum {key}')
        ranked = sorted(strata[key], key=lambda r: hashlib.sha256(f'{SPLIT_SEED}:{r["id"]}'.encode()).hexdigest())
        selected.extend(r['id'] for r in ranked[:quotas[key]])
    assert len(selected) == count
    return set(selected), {'seed': SPLIT_SEED, 'rows': count,
                          'method': 'source/category largest remainder; SHA256(seed:id) rank; unique prompts only',
                          'strata': {'::'.join(k): v for k, v in sorted(quotas.items())}}


def build(source, root):
    rows = pq.read_table(source / 'sft_original.parquet').to_pylist()
    if len(rows) != 21879 or len({r['id'] for r in rows}) != 21879:
        raise ValueError('Expected the original 21,879 distinct SFT rows')
    for row in rows:
        row['raw_primary_category'] = row['primary_category']
        row['raw_overlap_categories'] = row['overlap_categories']
        row['primary_category'] = formal(row['primary_category'])
        row['overlap_categories'] = sorted({formal(x) for x in
            (row['raw_overlap_categories'] or [row['raw_primary_category']])})
    selected, policy = choose_validation(rows)
    full_table = pa.Table.from_pylist(rows)
    full_table = full_table.append_column('problem_id', full_table['id'])
    full_table = full_table.append_column('response', full_table['answer'])
    full_table = full_table.append_column('source_row_index', pa.array(range(len(rows)), type=pa.int32()))
    for split in ['train', 'validation']:
        indices = [i for i, r in enumerate(rows) if (r['id'] in selected) == (split == 'validation')]
        write_parquet(root / 'data/taco_leetcode/sft' / (split + '.parquet'), full_table.take(pa.array(indices)))
    categories = load_json(source / 'category_index.json')
    rl_ids = {}
    for split in ['train', 'validation']:
        table = pq.read_table(source / ('rl_' + split + '.parquet'))
        infos = table['extra_info'].to_pylist()
        ids = [info['problem_id'] for info in infos]
        rl_ids[split] = ids
        if not set(ids) <= categories.keys():
            raise ValueError('Missing original RL category index')
        # Retain model names and counts, without machine-specific filesystem paths.
        for info in infos:
            token_counts = info.get('prompt_tokens_by_model')
            if token_counts:
                info['prompt_tokens_by_model'] = {Path(k).name: v for k, v in token_counts.items()}
        table = table.set_column(table.schema.get_field_index('extra_info'), 'extra_info', pa.array(infos))
        table = table.append_column('problem_id', pa.array(ids))
        table = table.append_column('primary_category', pa.array([formal(categories[x]['primary_category']) for x in ids]))
        table = table.append_column('overlap_categories', pa.array([
            sorted({formal(v) for v in (categories[x]['overlap_categories'] or [categories[x]['primary_category']])})
            for x in ids], type=pa.list_(pa.string())))
        write_parquet(root / 'data/taco_leetcode/rl' / (split + '.parquet'), table)
    recorded = load_json(source / 'memberships.json')
    membership = {'version': '1.0.0', 'sft_historical': {}, 'sft_release': {}, 'rl_historical': {},
                  'sft_rule': 'Frozen original arms, followed by removal of the new SFT holdout for release arms.',
                  'rl_rule': 'Remove every intersecting overlap category; frozen seed-20260610 12,168-row samples.',
                  'split_seed': SPLIT_SEED, 'validation_ids': sorted(selected)}
    for arm, ids in recorded['sft'].items():
        removed = arm[3:] if arm.startswith('no_') else None
        membership['sft_historical'][arm] = member_record(ids, removed)
        membership['sft_release'][arm] = member_record([x for x in ids if x not in selected], removed)
    membership['rl_historical']['full_dapo'] = member_record(rl_ids['train'])
    for arm, ids in recorded['rl'].items():
        membership['rl_historical'][arm] = member_record(ids, arm[3:] if arm.startswith('no_') else None)
    metadata = root / 'metadata/taco_leetcode'
    write_json(metadata / 'ablation_membership.json', membership, compact=True)
    write_json(metadata / 'taxonomy.json', {'name': 'taco_leetcode_legacy_7', 'version': '1.0.0',
               'categories': CATEGORIES, 'unlabeled_value': 'no_tags', 'raw_to_formal': RAW_TO_FORMAL,
               'ablation_rule': 'Remove any row whose overlap_categories contains the selected category.'})
    policy['origin'] = 'Added for this release; not the historical experiment validation set.'
    policy['historical_sft_rows'] = 21879
    policy['historical_rl_validation_overlap_with_original_sft_train'] = len(set(rl_ids['validation']) & {r['id'] for r in rows})
    make_manifest(root, 'taco_leetcode', {'sft': policy, 'rl': 'Original 17,249 train + 100 validation'})


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--source', type=Path, help='Frozen source export directory')
    parser.add_argument('--root', type=Path, default=ROOT)
    parser.add_argument('--arm')
    parser.add_argument('--kind', choices=['sft', 'rl'], default='sft')
    parser.add_argument('--historical', action='store_true', help='Restore original SFT membership including the new holdout')
    parser.add_argument('--output', type=Path)
    args = parser.parse_args()
    if args.arm:
        if args.output is None:
            parser.error('--output is required with --arm')
        members = load_json(args.root / 'metadata/taco_leetcode/ablation_membership.json')
        kind = 'rl_historical' if args.kind == 'rl' else 'sft_historical' if args.historical else 'sft_release'
        table = pq.read_table(args.root / 'data/taco_leetcode' / args.kind / 'train.parquet')
        if args.kind == 'sft' and args.historical:
            table = pa.concat_tables([table, pq.read_table(args.root / 'data/taco_leetcode/sft/validation.parquet')])
            table = table.set_column(table.schema.get_field_index('primary_category'), 'primary_category', table['raw_primary_category'])
            table = table.set_column(table.schema.get_field_index('overlap_categories'), 'overlap_categories', table['raw_overlap_categories'])
        export_rows(table, members[kind][args.arm]['problem_ids'], args.output)
    elif args.source:
        build(args.source, args.root)
    else:
        parser.error('Use --source to build or --arm NAME --output FILE to export.')


if __name__ == '__main__':
    main()