# unit_parser_fixed.py
import re
from typing import Optional

# =============================
# Currency / money patterns
# =============================
CURRENCY_PREFIX = r"[$£€₹¥₩₦]|A\$|C\$|CHF|د\.إ"
MONEY_RE = re.compile(
    rf"(?P<prefix>{CURRENCY_PREFIX})?\s*(?P<val>\d+(?:,\d{{3}})*(?:\.\d{{1,2}})?)\s*(?P<word>(?:[a-zA-Z]+(?:\s[a-zA-Z]+)?)s?)?",
    re.IGNORECASE,
)

# =============================
# Unit / group price patterns
# =============================
UNIT_LIKE_RE = re.compile(
    r"(?P<q1>\d+)\s+(?P<item>[\w\s]+?)\s+(?:is|are|cost|costs|priced at|=)\s+"
    r"(?P<cost>\d+(?:,\d{3})*(?:\.\d+)?(?:\s*\w+)?)"
    r"[,\.]?\s*(?:how much|what\s*'?s|price|cost).*?(?P<q2>\d+)\s+(?P=item)\b",
    re.IGNORECASE,
)

GROUP_LIKE_RE = re.compile(
    r"(?P<q1>\d+)\s+(?P<item>\w+?s?)\s+for\s+(?P<cost>.+?)\b[,\.]?\s*(?:how much|what\s*'?s|price|cost).*?(?P<q2>\d+)\s+(?P=item)\b",
    re.IGNORECASE,
)

ADD_RE = re.compile(r"^\s*([\d+\s=\?]+)\s*$")
NUM_RE = re.compile(r"\d+")

# =============================
# Helpers
# =============================
def money(v: float) -> str:
    return str(int(round(v))) if abs(v - round(v)) < 1e-9 else f"{v:.2f}"

def parse_money_str(s: str) -> str:
    m = MONEY_RE.search(s)
    if not m:
        return s.strip()
    prefix = (m.group('prefix') or '').strip()
    val = float((m.group('val') or '').replace(',', ''))
    word = (m.group('word') or '').strip()
    if prefix:
        return f"{prefix}{money(val)}"
    if word:
        if word.lower().endswith('s') and abs(val-1.0) < 1e-9:
            word = word[:-1]
        return f"{money(val)} {word}"
    return money(val)

# =============================
# Canonicalizers
# =============================
def canonicalize_nl(text: str) -> Optional[str]:
    t = text.strip()

    m = UNIT_LIKE_RE.search(t)
    if m:
        q1 = int(m.group('q1')); item = m.group('item').rstrip('.')
        cost = parse_money_str(m.group('cost'))
        q2 = int(m.group('q2'))
        return f"q: {q1} {item} cost {cost}. how much is {q2} {item}? a:"

    m = GROUP_LIKE_RE.search(t)
    if m:
        q1 = int(m.group('q1')); item = m.group('item').rstrip('.')
        cost = parse_money_str(m.group('cost'))
        q2 = int(m.group('q2'))
        return f"q: {q1} {item} for {cost}, what's the price for {q2} {item}? a:"

    return None

def is_addition_query(text: str) -> bool:
    t = text.strip()
    if not ADD_RE.match(t):
        return False
    return ('+' in t) and (len(NUM_RE.findall(t)) >= 2)

def canonicalize_addition(text: str) -> str:
    nums = [int(x) for x in NUM_RE.findall(text)]
    return " + ".join(str(n) for n in nums)

def sum_addends(text: str) -> int:
    return sum(int(x) for x in NUM_RE.findall(text))

# =============================
# Deterministic solver
# =============================
_NUMBER_TOKEN_RE = re.compile(r"\d+(?:,\d{3})*(?:\.\d+)?")

def try_solve_unit_like(text: str) -> Optional[str]:
    m = UNIT_LIKE_RE.search(text)
    if not m:
        return None

    q1 = int(m.group('q1'))
    q2 = int(m.group('q2'))
    item = (m.group('item') or '').strip().rstrip('.')
    cost_raw = (m.group('cost') or '').strip()

    nums = _NUMBER_TOKEN_RE.findall(cost_raw)
    if not nums:
        return None
    token = max(nums, key=lambda s: len(s.replace(',', '')))
    cost_val = float(token.replace(',', ''))

    if q1 == 0:
        return "final answer: undefined"

    unit = cost_val / q1
    total = unit * q2

    mcur = MONEY_RE.search(cost_raw)
    prefix = (mcur.group('prefix') or '').strip() if mcur else ''
    word   = (mcur.group('word') or '').strip()   if mcur else ''

    def _fmt(v: float) -> str:
        s = money(v)
        if prefix:
            return f"{prefix}{s}"
        if word:
            sing = word[:-1] if word.lower().endswith('s') and abs(v-1.0) < 1e-9 else word
            return f"{s} {sing}"
        return s

    base_item = item[:-1] if item.lower().endswith('s') else item
    return (
        f"step 1: find unit price: {_fmt(cost_val)} / {q1} = {_fmt(unit)} per {base_item}. "
        f"step 2: multiply by {q2}: {_fmt(unit)} × {q2} = {_fmt(total)}. "
        f"final answer: {_fmt(total)}"
    )