#!/usr/bin/env python3
"""Generate the figures of the paper from results.json (build_data.py) into <output>/figures/."""
import json
import os

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Patch
import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
RES_DIR = OUT_ROOT = os.path.join(HERE, 'output')
FIG = os.path.join(OUT_ROOT, 'figures')
os.makedirs(FIG, exist_ok=True)
R = json.load(open(os.path.join(RES_DIR, 'results.json')))
CF = R['configs']

OPEN = ['qwen-3.5-27b', 'qwen-3.5-122b-a10b', 'gemma-4-31b', 'glm-4.7-flash',
        'gpt-oss-20b', 'gpt-oss-120b', 'minimax-m2.5']
FRONTIER = ['seed-2.0', 'gpt-5.4']
DISP = {'qwen-3.5-27b': 'Qwen3.5-27B', 'qwen-3.5-122b-a10b': 'Qwen3.5-122B-A10B', 'gemma-4-31b': 'Gemma4-31B',
        'glm-4.7-flash': 'GLM-4.7-Flash', 'gpt-oss-20b': 'GPT-OSS-20B', 'gpt-oss-120b': 'GPT-OSS-120B',
        'minimax-m2.5': 'MiniMax-M2.5', 'seed-2.0': 'Seed-2.0', 'gpt-5.4': 'GPT-5.4'}
METHODS = ['rag-nothink', 'rag-think', 'miniswe', 'openhands', 'claude']
AGENTS = ['miniswe', 'openhands', 'claude']
MDISP = {'rag-nothink': 'RAG-NoThink', 'rag-think': 'RAG-Think', 'miniswe': 'Mini-SWE-Agent',
         'openhands': 'OpenHands', 'claude': 'Claude-Code', 'rag': 'RAG'}
# validated categorical palette (dataviz validate_palette.js, light): CVD warn band on
# red/aqua -> every method also gets its own marker (secondary encoding).
MCOL = {'rag-nothink': '#2a78d6', 'rag-think': '#4a3aa7', 'miniswe': '#eb6834',
        'openhands': '#1baf7a', 'claude': '#e34948', 'rag': '#2a78d6'}
MMARK = {'rag-nothink': 'o', 'rag-think': 's', 'miniswe': '^', 'openhands': 'D', 'claude': 'v', 'rag': 'o'}
CATS = ['Image', 'Video/Audio', 'Documents', 'Fonts', 'Data Formats', 'Compilers/Interpreters',
        'Binaries', 'Network', 'Others']
CAT_SHORT = {'Image': 'Image', 'Video/Audio': 'A/V', 'Documents': 'Doc', 'Fonts': 'Font',
             'Data Formats': 'Data', 'Compilers/Interpreters': 'Code', 'Binaries': 'Bin',
             'Network': 'Net', 'Others': 'Other'}
INK, INK2, GRID = '#0b0b0b', '#52514e', '#e4e3df'

plt.rcParams.update({
    'font.size': 10, 'axes.edgecolor': '#b5b4ae', 'axes.labelcolor': INK, 'xtick.color': INK2,
    'ytick.color': INK2, 'axes.spines.top': False, 'axes.spines.right': False,
    'axes.grid': True, 'grid.color': GRID, 'grid.linewidth': 0.6, 'axes.axisbelow': True,
    'legend.frameon': False, 'pdf.fonttype': 42, 'ps.fonttype': 42,
})


def cid(model, mk):
    return f'{mk}|{model}'


def best_open(mk):
    """best open-weight LLM for a method, by pass@k_max."""
    return max(OPEN, key=lambda m: (CF[cid(m, mk)]['pass'][str(CF[cid(m, mk)]['N'])],
                                    CF[cid(m, mk)]['pass']['1']))


def best_any(mk):
    models = OPEN if mk.startswith('rag') else OPEN + FRONTIER
    return max(models, key=lambda m: CF[cid(m, mk)]['pass']['1'])


def curve(c, field, cat=None):
    N = c['N']
    if cat is None:
        return [c[field][str(k)] for k in range(1, N + 1)]
    return [c['per_category_pass'][cat][str(k)] for k in range(1, N + 1)]


def draw_kcurves(ax, field='pass', cat=None, legend=True, small=False, open_mode='best'):
    """solid: open-weight curve per method ('best' LLM, or 'mean' over the 7 LLMs);
    dashed: Seed-2.0 per agent; star: GPT-5.4 per agent (k=1 only)."""
    ms = 5 if small else 6
    for mk in METHODS:
        if open_mode == 'best':
            m = best_open(mk)
            y = curve(CF[cid(m, mk)], field, cat)
            lab = f'{MDISP[mk]} ({DISP[m]})'
        else:
            ys = [curve(CF[cid(m, mk)], field, cat) for m in OPEN]
            y = list(np.mean(ys, axis=0))
            lab = MDISP[mk]
        ax.plot(range(1, len(y) + 1), y, color=MCOL[mk], marker=MMARK[mk], ms=ms, lw=1.6, label=lab)
    for mk in AGENTS:
        y = curve(CF[cid('seed-2.0', mk)], field, cat)
        ax.plot(range(1, len(y) + 1), y, color=MCOL[mk], marker=MMARK[mk], ms=ms, lw=1.4,
                ls='--', mfc='white')
        y = curve(CF[cid('gpt-5.4', mk)], field, cat)
        ax.plot([1], y, color=MCOL[mk], marker='*', ms=ms + 6, ls='none', mec='white', mew=0.6)
    ax.set_xticks(range(1, 6))
    if legend:
        h, l = ax.get_legend_handles_labels()
        style = [Line2D([], [], color=INK2, lw=1.6,
                        label='best open-weight LLM' if open_mode == 'best' else 'mean of 7 open-weight LLMs'),
                 Line2D([], [], color=INK2, lw=1.4, ls='--', marker='o', mfc='white', label='Seed-2.0'),
                 Line2D([], [], color=INK2, ls='none', marker='*', ms=12, label='GPT-5.4 (1 sample)')]
        return h + style
    return None


def fig_kcurves(field, fname, ylabel, loc='upper right'):
    fig, ax = plt.subplots(figsize=(6.3, 3.9))
    hs = draw_kcurves(ax, field)
    ax.set_xlabel('k')
    ax.set_ylabel(ylabel)
    ax.set_xlim(0.8, 5.2)
    ax.legend(handles=hs, loc=loc, fontsize=8, handlelength=2.0, labelspacing=0.3)
    fig.tight_layout()
    fig.savefig(os.path.join(FIG, fname), bbox_inches='tight')
    plt.close(fig)


def fig_funnel():
    rows = [('openhands', 'gpt-oss-120b'), ('miniswe', 'minimax-m2.5'), ('claude', 'gpt-oss-120b'),
            ('claude', 'minimax-m2.5'), ('openhands', 'seed-2.0'), ('openhands', 'gpt-5.4'),
            ('claude', 'gpt-5.4')]
    bands = ['pass', 'reach \\ pass', 'sfunc \\ reach', 'miss function', 'no output']
    cols = ['#1c5cab', '#5598e7', '#9ec5f4', '#d9d8d3', '#7a7974']
    fig, ax = plt.subplots(figsize=(8.3, 2.35))
    ys = np.arange(len(rows))[::-1]
    for y, (mk, m) in zip(ys, rows):
        f = CF[cid(m, mk)]['funnel']
        left = 0.0
        for b, c in zip(bands, cols):
            ax.barh(y, f[b], left=left, color=c, height=0.72, edgecolor='white', linewidth=1.0)
            left += f[b]
        ax.text(f['pass'] / 2, y, f"{f['pass']:.1f}", ha='center', va='center', color='white', fontsize=8)
    ax.axhline(ys[3] - 0.5, color=INK2, lw=0.8, ls=':')
    ax.set_yticks(ys)
    ax.set_yticklabels([f'{MDISP[mk]} | {DISP[m]}' for mk, m in rows], fontsize=9)
    ax.set_xlim(0, 100)
    ax.grid(axis='y', visible=False)
    ax.legend(handles=[Patch(color=c, label=b) for b, c in zip(bands, cols)], ncol=5,
              loc='upper center', bbox_to_anchor=(0.5, -0.16), fontsize=9)
    fig.tight_layout()
    fig.savefig(os.path.join(FIG, 'f2_funnel.pdf'), bbox_inches='tight')
    plt.close(fig)


def fig_method_cat():
    rows = [(mk, best_any(mk)) for mk in METHODS]
    M = np.array([[CF[cid(m, mk)]['per_category_pass'][c]['1'] for c in CATS] + [CF[cid(m, mk)]['pass']['1']]
                  for mk, m in rows])
    fig, ax = plt.subplots(figsize=(9.2, 2.45))
    im = ax.imshow(M, cmap='Blues', vmin=0, vmax=max(70, M.max()), aspect='auto')
    for i in range(M.shape[0]):
        for j in range(M.shape[1]):
            v = M[i, j]
            ax.text(j, i, f'{v:.1f}', ha='center', va='center', fontsize=8.5,
                    color='white' if v > 38 else INK)
    ax.set_xticks(range(len(CATS) + 1))
    ax.set_xticklabels([CAT_SHORT[c] for c in CATS] + ['Overall'])
    ax.set_yticks(range(len(rows)))
    ax.set_yticklabels([f'{MDISP[mk]}\n({DISP[m]})' for mk, m in rows], fontsize=8.5)
    ax.grid(False)
    ax.axvline(len(CATS) - 0.5, color='white', lw=2)
    cb = fig.colorbar(im, ax=ax, fraction=0.025, pad=0.01)
    cb.set_label('pass@1 (%)')
    fig.tight_layout()
    fig.savefig(os.path.join(FIG, 'f3_method_cat.pdf'), bbox_inches='tight')
    plt.close(fig)


def fig_upset(key, set_order, set_labels, fname):
    inter = R[key]
    items = [(k, v) for k, v in inter.items() if k != '(none)']
    items.sort(key=lambda x: -x[1])
    items.append(('(none)', inter.get('(none)', 0)))
    fig = plt.figure(figsize=(10.9, 3.0))
    gs = fig.add_gridspec(2, 1, height_ratios=[2.3, 1.1], hspace=0.05)
    ax = fig.add_subplot(gs[0])
    ax2 = fig.add_subplot(gs[1], sharex=ax)
    x = np.arange(len(items))
    cols = ['#3d3c39'] * (len(items) - 1) + ['#e34948']
    ax.bar(x, [v for _, v in items], color=cols, width=0.72)
    for xi, (_, v) in zip(x, items):
        ax.text(xi, v + 3, str(v), ha='center', va='bottom', fontsize=8.5, color=INK)
    ax.set_ylabel('# tasks')
    ax.tick_params(axis='x', bottom=False, labelbottom=False)
    ax.set_ylim(0, max(v for _, v in items) * 1.15)
    ax.grid(axis='x', visible=False)
    for yi, s in enumerate(set_order):
        yy = len(set_order) - 1 - yi
        for xi, (k, _) in zip(x, items):
            on = k != '(none)' and s in k.split('|')
            ax2.scatter(xi, yy, s=55, color=MCOL[s] if on else '#dcdbd6', zorder=3)
    for xi, (k, _) in zip(x, items):
        if k == '(none)':
            continue
        ys = [len(set_order) - 1 - set_order.index(s) for s in k.split('|')]
        if len(ys) > 1:
            ax2.plot([xi, xi], [min(ys), max(ys)], color='#3d3c39', lw=1.6, zorder=2)
    ax2.set_yticks(range(len(set_order)))
    ax2.set_yticklabels(set_labels[::-1], fontsize=9)
    ax2.set_ylim(-0.6, len(set_order) - 0.4)
    ax2.tick_params(axis='x', bottom=False, labelbottom=False)
    ax2.grid(False)
    for sp in ('left', 'bottom'):
        ax2.spines[sp].set_visible(False)
    fig.savefig(os.path.join(FIG, fname), bbox_inches='tight')
    plt.close(fig)


def jaccard(a, b):
    a, b = set(a), set(b)
    return len(a & b) / len(a | b) if a | b else 0.0


def fig_jaccard():
    solved = {k: set(v['solved']) for k, v in CF.items()}
    msets = {'rag': set().union(*[solved[cid(m, mk)] for m in OPEN for mk in ('rag-think', 'rag-nothink')])}
    for mk in AGENTS:
        msets[mk] = set().union(*[solved[cid(m, mk)] for m in OPEN + FRONTIER])
    mo = ['rag'] + AGENTS
    A = np.array([[jaccard(msets[a], msets[b]) for b in mo] for a in mo])
    models = OPEN + FRONTIER
    best = {}
    for m in models:
        mks = AGENTS if m in FRONTIER else METHODS
        mk = max(mks, key=lambda x: (CF[cid(m, x)]['pass'][str(CF[cid(m, x)]['N'])], CF[cid(m, x)]['pass']['1']))
        best[m] = solved[cid(m, mk)]
    B = np.array([[jaccard(best[a], best[b]) for b in models] for a in models])
    fig, (a1, a2) = plt.subplots(1, 2, figsize=(11.5, 4.6), gridspec_kw={'width_ratios': [1, 1.45]})
    for ax, M, labs, title in ((a1, A, [MDISP[m] for m in mo], 'Method-level Jaccard'),
                               (a2, B, [DISP[m] for m in models], 'Model-level Jaccard (best method per model)')):
        im = ax.imshow(M, cmap='Blues', vmin=0, vmax=1)
        for i in range(M.shape[0]):
            for j in range(M.shape[1]):
                ax.text(j, i, f'{M[i, j]:.2f}', ha='center', va='center', fontsize=8 if M.shape[0] > 5 else 9.5,
                        color='white' if M[i, j] > 0.6 else INK)
        ax.set_xticks(range(len(labs)))
        ax.set_xticklabels(labs, rotation=25, ha='right', fontsize=9)
        ax.set_yticks(range(len(labs)))
        ax.set_yticklabels(labs, fontsize=9)
        ax.grid(False)
        ax.set_title(title, fontsize=11)
        fig.colorbar(im, ax=ax, fraction=0.046, pad=0.03)
    fig.tight_layout()
    fig.savefig(os.path.join(FIG, 'fa3b_jaccard.pdf'), bbox_inches='tight')
    plt.close(fig)


def fig_anatomy():
    labels = ['Pass', 'Exec success (cov-miss)', 'Code error', 'Missing/invalid output', 'Timeout',
              'Resource exceeded', 'No output']
    cols = ['#1c5cab', '#9ec5f4', '#e34948', '#eb6834', '#eda100', '#e87ba4', '#b5b4ae']
    panels = ['rag-think'] + AGENTS
    models = OPEN + FRONTIER
    fig, axes = plt.subplots(1, 4, figsize=(14.3, 5.3), sharey=True)
    ys = np.arange(len(models))[::-1]
    for ax, mk in zip(axes, panels):
        for y, m in zip(ys, models):
            c = CF.get(cid(m, mk))
            if c is None:
                ax.text(50, y, 'not evaluated', ha='center', va='center', fontsize=8.5, color=INK2)
                continue
            left = 0.0
            for l, col in zip(labels, cols):
                v = c['anatomy'][l]
                ax.barh(y, v, left=left, color=col, height=0.72, edgecolor='white', linewidth=0.8)
                left += v
        ax.axhline(ys[len(OPEN) - 1] - 0.5, color=INK2, lw=0.8, ls=':')
        ax.set_title(MDISP[mk], fontsize=11)
        ax.set_xlim(0, 100)
        ax.grid(axis='y', visible=False)
    axes[0].set_yticks(ys)
    axes[0].set_yticklabels([DISP[m] for m in models])
    fig.legend(handles=[Patch(color=c, label=l) for l, c in zip(labels, cols)], ncol=4,
               loc='lower center', bbox_to_anchor=(0.5, -0.02), fontsize=10)
    fig.tight_layout(rect=(0, 0.1, 1, 1))
    fig.savefig(os.path.join(FIG, 'fa4_anatomy.pdf'), bbox_inches='tight')
    plt.close(fig)


def fig_percat():
    fig, axes = plt.subplots(3, 3, figsize=(10.9, 9.2), sharey=True)
    hs = None
    for ax, cat in zip(axes.flat, CATS):
        h = draw_kcurves(ax, 'pass', cat, legend=True, small=True, open_mode='mean')
        hs = hs or h
        ax.set_title(cat, fontsize=10)
        ax.set_ylim(-2, 80)
    for ax in axes[:, 0]:
        ax.set_ylabel('pass@k (%)')
    for ax in axes[-1]:
        ax.set_xlabel('k')
    fig.legend(handles=hs, ncol=4, loc='lower center', bbox_to_anchor=(0.5, -0.06), fontsize=9)
    fig.tight_layout()
    fig.savefig(os.path.join(FIG, 'fa5_per_cat_passk.pdf'), bbox_inches='tight')
    plt.close(fig)


def main():
    fig_kcurves('pass', 'f1_passk.pdf', 'pass@k (%)')
    fig_kcurves('reach', 'fa1_reachk.pdf', 'reach@k (%)', loc='lower right')
    fig_kcurves('sfunc', 'fa1_sfunck.pdf', 'sfunc@k (%)', loc='lower right')
    fig_funnel()
    fig_method_cat()
    fig_upset('upset_final', ['rag'] + AGENTS, ['RAG', 'Mini-SWE-Agent', 'OpenHands', 'Claude-Code'],
              'f4_method_upset.pdf')
    fig_upset('upset_open', ['rag'] + AGENTS, ['RAG', 'Mini-SWE-Agent', 'OpenHands', 'Claude-Code'],
              'fa3a_upset_detailed.pdf')
    fig_jaccard()
    fig_anatomy()
    fig_percat()
    print('figures written to', os.path.abspath(FIG))


if __name__ == '__main__':
    main()