"""Reproducible CPU reports. No network, dependencies, randomness or credentials."""
import argparse
import hashlib
import importlib
import json
import math
from pathlib import Path
import platform


def sigmoid(value):
    return 1 / (1 + math.exp(-value)) if value >= 0 else math.exp(value) / (1 + math.exp(value))


def mse(left, right):
    return sum((a - b) ** 2 for a, b in zip(left, right)) / len(left)


def matvec(matrix, vector):
    return [sum(a * b for a, b in zip(row, vector)) for row in matrix]


def experiment(topic, implementation, fixtures, beta=1, bits=4, format_weight=0.2):
    m = implementation
    data = fixtures[topic]
    if topic == 'rlhf':
        theta = 0.0
        history = []
        for step in range(6):
            p = sigmoid(theta)
            kl = p * math.log(2 * p) + (1 - p) * math.log(2 * (1 - p))
            history.append({'step': step, 'theta': theta, 'p_A': p, 'pair_loss_nats': m.dpo_loss(theta, 0, beta), 'kl_nats': kl, 'independent_correct_probability': 1 - p})
            if step < 5:
                theta -= 0.2 * m.dpo_gradient(theta, beta)
        delta = 1e-5
        numerical = (m.dpo_loss(delta, 0, beta) - m.dpo_loss(-delta, 0, beta)) / (2 * delta)
        return {'train_id': data['train_id'], 'transfer_id': data['transfer_id'], 'prompt': data['prompt'], 'responses': data['responses'], 'reference': data['reference'], 'learning_rate': 0.2, 'history': history, 'initial_gradient': m.dpo_gradient(0, beta), 'finite_difference_gradient': numerical, 'transfer_used_for_selection': False}
    if topic == 'lora':
        W, A, B, x, alpha = (data[k] for k in ('W', 'A', 'B', 'worked_input', 'alpha'))
        merged = m.merge(W, A, B, alpha)
        E, held_out = data['evaluation_base'], data['transfer_input']
        codes, scale = m.quantize([v for row in E for v in row], bits)
        restored = [v * scale for v in codes]
        Q = [restored[:2], restored[2:]]
        base = matvec(E, held_out)
        adapted = m.lora_forward(E, A, B, held_out, alpha)
        quantized = matvec(Q, held_out)
        quantized_adapted = m.lora_forward(Q, A, B, held_out, alpha)
        return {'worked_forward': m.lora_forward(W, A, B, x, alpha), 'worked_merged_forward': matvec(merged, x), 'original_W': W, 'held_out_input': held_out, 'four_way_outputs': {'base': base, 'adapter': adapted, 'quantized_base': quantized, 'quantized_adapter': quantized_adapted}, 'weight_mse': mse([v for row in E for v in row], restored), 'base_output_mse': mse(base, quantized), 'adapter_output_mse': mse(adapted, quantized_adapted), 'scale': scale, 'codes': codes, 'target_note': 'Errors relative to matching full-precision paths, not task accuracy. Adapters supplied, not trained.'}
    correctness = [int(answer == data['correct_answer']) for answer in data['answers']]
    rewards = [correct + format_weight * style for correct, style in zip(correctness, data['format_scores'])]
    adv = m.advantages(rewards)
    contributions = [m.surrogate(ratios, a, mask) for ratios, a, mask in zip(data['ratios'], adv, data['masks'])]
    return {'prompt_id': data['prompt_id'], 'correctness': correctness, 'format_scores': data['format_scores'], 'rewards': rewards, 'advantages': adv, 'response_contributions': contributions, 'group_mean_surrogate': sum(contributions) / len(contributions), 'transfer_equal_group': m.advantages(data['transfer_group_rewards']), 'reduction': 'valid token mean per response, then response mean; population std per prompt', 'kl_beta': 0, 'reference_note': 'Ratios refer to the frozen OLD policy. Reference-policy KL omitted, not silently approximated.'}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('topic', choices=['rlhf', 'lora', 'grpo'])
    parser.add_argument('--implementation', choices=['starter', 'reference'], default='starter')
    parser.add_argument('--beta', type=float, default=1)
    parser.add_argument('--bits', type=int, choices=[4, 8], default=4)
    parser.add_argument('--format-weight', type=float, default=0.2)
    parser.add_argument('--output', type=Path)
    args = parser.parse_args()
    if not math.isfinite(args.beta) or not 0 < args.beta <= 10 or not math.isfinite(args.format_weight) or not 0 <= args.format_weight <= 10:
        parser.error('Use 0 < beta <= 10 and 0 <= format-weight <= 10 for these fixtures')
    raw = Path(__file__).with_name('fixtures.json').read_bytes()
    fixtures = json.loads(raw)
    module = importlib.import_module(args.implementation)
    report = {'version': fixtures['version'], 'python': platform.python_version(), 'fixture_sha256': hashlib.sha256(raw).hexdigest(), 'implementation': args.implementation, 'topic': args.topic, 'configuration': {'beta': args.beta, 'bits': args.bits, 'format_weight': args.format_weight}, 'results': experiment(args.topic, module, fixtures, args.beta, args.bits, args.format_weight), 'claim_boundary': 'Finite synthetic mechanisms, not LLM training, measured GPU performance, safety certification or independent mastery.'}
    text = json.dumps(report, indent=2, allow_nan=False) + '\n'
    if args.output:
        # Refuse accidental replacement of an existing report or learner source.
        with args.output.open('x', encoding='utf-8') as target:
            target.write(text)
    else:
        print(text, end='')


if __name__ == '__main__':
    main()