"""BFCL-style AST matching (re-implemented, simplified) for predicted calls vs acceptable-value gold.

gold: [{func_name: {arg: [acceptable values]}}]; "" in the acceptable list means the arg may be omitted.
"""
from __future__ import annotations

import itertools
import re
from typing import Any

from .schema import Call


def _std(s: str) -> str:
    return re.sub(r"[ ,./\-_*^]", "", str(s)).lower().replace("'", '"')


def _num(x):
    if isinstance(x, bool):
        return None
    if isinstance(x, (int, float)):
        return float(x)
    if isinstance(x, str):
        try:
            return float(x)
        except ValueError:
            return None
    return None


def value_match(pred: Any, gold: Any) -> bool:
    if isinstance(gold, bool) or isinstance(pred, bool):
        if isinstance(pred, str):
            return pred.strip().lower() == str(gold).lower()
        return pred == gold
    gn, pn = _num(gold), _num(pred)
    if gn is not None and not isinstance(gold, str):
        return pn is not None and abs(pn - gn) < 1e-6
    if isinstance(gold, str):
        return _std(pred) == _std(gold) if not isinstance(pred, (list, dict)) else False
    if isinstance(gold, (list, tuple)):
        return isinstance(pred, (list, tuple)) and len(pred) == len(gold) and all(
            value_match(p, g) for p, g in zip(pred, gold))
    if isinstance(gold, dict):
        if not isinstance(pred, dict):
            return False
        for k, gv in gold.items():
            accept = gv if isinstance(gv, list) else [gv]
            if k not in pred:
                if "" not in accept:
                    return False
                continue
            if not any(value_match(pred[k], a) for a in accept if a != ""):
                return False
        return set(pred) <= set(gold)
    return pred == gold


def call_match(pred: Call, gold_call: dict) -> bool:
    (name, accept), = gold_call.items()
    if pred.name != name:
        return False
    for k, v in pred.args.items():
        if k not in accept:
            return False
        if not any(value_match(v, a) for a in accept[k] if not (isinstance(a, str) and a == "")):
            if not ("" in accept[k] and v in ("", None)):
                return False
    for k, vals in accept.items():
        if k not in pred.args and "" not in vals:
            return False
    return True


def match_calls(pred: list[Call], gold: list[dict]) -> bool:
    if len(pred) != len(gold):
        return False
    if not gold:
        return True
    for perm in itertools.permutations(range(len(pred))):
        if all(call_match(pred[perm[g]], gold[g]) for g in range(len(gold))):
            return True
    return False


def names_match(pred: list[Call], gold: list[dict]) -> bool:
    return sorted(c.name for c in pred) == sorted(next(iter(g)) for g in gold)