#!/usr/bin/env python3
"""Character-length distributions for the frozen dialogue extraction corpus."""
import argparse
from collections import defaultdict
import csv
import json
import math
from pathlib import Path

from extract_dialogues import ROOT, file_hash, iter_jsonl, ordered_segments, write_json


def percentile(values, fraction):
    position = (len(values) - 1) * fraction
    lower = math.floor(position)
    upper = math.ceil(position)
    return round(values[lower] + (values[upper] - values[lower]) * (position - lower), 1)


def summarize(rows):
    values = sorted(r['chars'] for r in rows)
    total = sum(values)
    edges = [1000, 3000, 6000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000]
    bins = []
    lower = 0
    for upper in edges + [None]:
        matched = [n for n in values if n >= lower and (upper is None or n <= upper)]
        bins.append({'min_chars': lower, 'max_chars': upper, 'count': len(matched),
                     'percent': round(100 * len(matched) / len(values), 2),
                     'text_percent': round(100 * sum(matched) / total, 2) if total else 0})
        if upper is not None:
            lower = upper + 1
    return {'count': len(values), 'total_chars': total, 'min': values[0],
            'mean': round(total / len(values), 1),
            **{f'p{int(p * 100):02d}': percentile(values, p) for p in (.25, .5, .75, .9, .95, .99)},
            'max': values[-1], 'bins': bins,
            'thresholds': {str(threshold): {
                'count_le': sum(n <= threshold for n in values),
                'percent_le': round(100 * sum(n <= threshold for n in values) / len(values), 2),
                'text_percent_le': round(100 * sum(n for n in values if n <= threshold) / total, 2) if total else 0}
                for threshold in (6000, 10000, 20000, 50000, 100000)}}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--input', type=Path, default=ROOT / 'unified/pretrain-v1/build-003/pretrain.jsonl')
    parser.add_argument('--output', type=Path, required=True)
    args = parser.parse_args()
    args.output.mkdir(parents=True, exist_ok=False)
    works = defaultdict(list)
    records = defaultdict(list)
    for doc in iter_jsonl(args.input):
        if doc.get('source') not in ('minhon', 'wikisource'):
            continue
        work_id = doc.get('source_document_id') or doc['id']
        thin = {k: doc.get(k) for k in ('id', 'source', 'unit_label', 'title')}
        thin.update(work_id=work_id, chars=len(doc['text']))
        works[(doc['source'], work_id)].append(thin)
        records[doc['source']].append(thin)
    work_rows, segments = defaultdict(list), defaultdict(list)
    for (source, work_id), docs in works.items():
        parts = ordered_segments(docs)
        work_rows[source].append({'id': work_id, 'title': docs[0]['title'],
                                  'chars': sum(d['chars'] for d in docs),
                                  'records': len(docs), 'segments': len(parts)})
        for index, part in enumerate(parts):
            segments[source].append({'id': f'{work_id}#segment-{index + 1}',
                                      'title': part[0]['title'],
                                      'chars': sum(d['chars'] for d in part) + len(part) - 1,
                                      'records': len(part), 'work_id': work_id})
    report = {'input': str(args.input.resolve()), 'input_sha256': file_hash(args.input),
              'unit': 'Unicode code points, including whitespace; not tokens',
              'work_definition': 'source_document_id within source; editions remain separate',
              'work_chars': 'sum of record lengths; no gap filling or implied concatenation',
              'segment_definition': 'same ordered_segments policy as extract_dialogues.py; '
                                    'consecutive numeric minhon pages joined with one LF; '
                                    'Wikisource articles remain separate',
              'percentile_method': 'linear interpolation at (n-1)*p',
              'distributions': {}}
    for source in sorted(records):
        report['distributions'][source] = {}
        for unit, rows in [('record', records[source]), ('work', work_rows[source]),
                           ('segment', segments[source])]:
            report['distributions'][source][unit] = summarize(rows)
            path = args.output / f'{source}.{unit}.csv'
            with open(path, 'w', newline='', encoding='utf-8') as f:
                writer = csv.DictWriter(f, fieldnames=list(rows[0]))
                writer.writeheader()
                writer.writerows(sorted(rows, key=lambda r: r['chars'], reverse=True))
    write_json(args.output / 'report.json', report)
    compact = {source: {unit: {k: v for k, v in stats.items() if k != 'bins'}
                        for unit, stats in units.items()}
               for source, units in report['distributions'].items()}
    print(json.dumps(compact, ensure_ascii=False, indent=2))


if __name__ == '__main__':
    main()