import ast
from collections import Counter, defaultdict
from dataclasses import dataclass
import json
from pathlib import Path
import re

from omegaconf import OmegaConf
from rich import print
from tqdm import tqdm

from functional_rl.envs import scalar
from functional_rl.v2_format import calculate
from refined_v4 import data as shared
from refined_v4.study import read, write
from .data import ROOT, small_final_calculation


@dataclass
class Config:
    root: str = str(ROOT)
    run: str = ''
    phase: str = 'sft'
    counter: int = 0


def failure(task: str, text: str, expected: str) -> str:
    if task == 'partial_gsm8k':
        match = re.fullmatch(r'So, the answer is (.+) = ([^\n]+)', text.splitlines()[-1])
        if not text.startswith('Answer: ') or match is None:
            return 'missing_equation_format'
        expression, answer = match.groups()
    elif task == 'arithmetic_simple':
        if not text.startswith('Answer: ') or ' = ' not in text:
            return 'missing_equation_format'
        pieces = text.removeprefix('Answer: ').split(' = ')
        expression, answer = pieces[:-1], pieces[-1]
    else:
        if '\nAnswer: ' not in text:
            return 'missing_answer_line'
        expression, answer = None, text.rsplit('\nAnswer: ', 1)[1]
    try:
        if scalar(answer) != scalar(expected):
            return 'wrong_number'
    except (ValueError, ZeroDivisionError):
        return 'non_numeric_answer'
    if expression is not None:
        try:
            expressions = expression if isinstance(expression, list) else [expression]
            if any(calculate(ast.parse(part, mode='eval')) != scalar(expected) for part in expressions):
                return 'wrong_expression'
        except (ValueError, SyntaxError, ZeroDivisionError, OverflowError):
            return 'invalid_expression'
    return 'correct'


def main(config: Config):
    root = Path(config.root)
    results = {}
    if config.run:
        if config.phase not in ('sft', 'rl'):
            raise ValueError('Development diagnostic phase must be sft or rl')
        folders = [Path(config.run)]
    else:
        folders = [folder for folder in sorted((root / 'verification').iterdir())
                   if (folder / 'result.json').exists()]
    for folder in tqdm(folders, desc='Inspect saved math completions', colour='cyan'):
        source = folder if config.run else Path(read(folder / 'protocol.json')['run'])
        request = read(source / 'request.json')['config']
        task = request['task']
        split = 'dev' if config.run else 'test'
        rows = {row['source_id']: row for row in shared.load_rows(Path(request['root']), task, split)}
        phases = {}
        for phase in ([config.phase] if config.run else ['sft', 'rl']):
            counter = (config.counter if config.run and config.counter else
                       request['sft_tokens' if phase == 'sft' else 'rl_rollouts'])
            filename = f'{phase if config.run else "test-" + phase}-{counter}.json'
            saved = read(folder / 'eval' / filename)
            by_hint = defaultdict(Counter)
            by_difficulty = defaultdict(Counter)
            examples = defaultdict(list)
            small = Counter()
            for question in saved['questions']:
                row = rows[question['source_id']]
                item = shared.make_episode(row, question['hint_level'])
                if item.prompt != question['prompt'] or item.prefix != question['prefix']:
                    raise ValueError('Saved evaluation prompt differs from the frozen source')
                for completion, passed in zip(question['completions'], question['passed'], strict=True):
                    verdict = shared.reward(item, completion)
                    if verdict != passed:
                        raise ValueError('Current numeric oracle differs from the saved verdict')
                    status = failure(task, item.prefix + completion, row['answer'])
                    if status == 'correct' and not verdict:
                        status = 'invalid_completion_length'
                    if status != 'correct' and verdict:
                        raise ValueError('Failure classification rejects a successful completion')
                    by_hint[str(item.hint_level)][status] += 1
                    by_difficulty[question['difficulty']][status] += 1
                    if small_final_calculation(dict(steps=row['provenance']['equations'])):
                        small[status] += 1
                    if len(examples[status]) < 3:
                        examples[status].append(dict(source_id=item.source_id, hint=item.hint_level,
                            prefix=item.prefix, reference=item.completion, completion=completion, answer=row['answer']))
            phases[phase] = dict(counter=counter, by_hint=dict(by_hint),
                by_difficulty=dict(by_difficulty), small_final=dict(small), examples=dict(examples))
            bands = {name: sum((by_hint[str(n)] for n in levels), Counter())
                for name, levels in [('1-2', range(1, 3)), ('3-8', range(3, 9)), ('9-16', range(9, 17))]}
            print(folder.name, phase, bands)
            if config.run:
                write(folder / 'diagnostics' / filename, phases[phase])
        results[folder.name] = dict(task=task, phases=phases)
    if not config.run:
        write(root / 'report-cache/failure-analysis.json', results)


if __name__ == '__main__':
    main(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config), OmegaConf.from_cli())))