formatting.py

from __future__ import annotations

import re
from typing import Any, List, Optional


def style_prefix(tone: float) -> str:
    if tone < 0.2:
        return ""
    if tone < 0.45:
        return "Ok —"
    if tone < 0.75:
        return "Let’s work through it."
    return "You’ve got this — let’s work through it step by step."


def _clean_lines(core: str) -> List[str]:
    lines: List[str] = []
    for line in (core or "").splitlines():
        cleaned = line.strip()
        if cleaned:
            lines.append(cleaned.lstrip("- ").strip())
    return lines


def _normalize_key(text: str) -> str:
    return re.sub(r"\s+", " ", (text or "").strip().lower())


def _dedupe_lines(lines: List[str]) -> List[str]:
    seen = set()
    out: List[str] = []
    for line in lines:
        key = _normalize_key(line)
        if key and key not in seen:
            seen.add(key)
            out.append(line.strip())
    return out


def _extract_topic_from_text(core: str, topic: Optional[str]) -> str:
    if topic:
        return str(topic).strip().lower()
    text = (core or "").lower()
    if "probability" in text or "favorable" in text or "sample space" in text:
        return "probability"
    if "percent" in text or "%" in text:
        return "percent"
    if "ratio" in text or "multiplier" in text:
        return "ratio"
    if "variable" in text or "equation" in text:
        return "algebra"
    if "variability" in text or "standard deviation" in text or "spread" in text:
        return "statistics"
    if "rectangle" in text or "perimeter" in text or "area" in text:
        return "geometry"
    return "general"


def _normalize_display_lines(lines: List[str]) -> List[str]:
    return [re.sub(r"\s+", " ", (line or "").strip()) for line in lines if str(line).strip()]


def _limit_steps(lines: List[str], verbosity: float, minimum: int = 1) -> List[str]:
    if not lines:
        return []
    if verbosity < 0.22:
        limit = minimum
    elif verbosity < 0.55:
        limit = max(minimum, min(2, len(lines)))
    elif verbosity < 0.82:
        limit = max(minimum, min(4, len(lines)))
    else:
        limit = len(lines)
    return lines[:limit]


def _why_line(topic: str) -> str:
    if topic == "algebra":
        return "Why this helps: reversing operations in the right order keeps the equation equivalent while you isolate the variable."
    if topic == "percent":
        return "Why this helps: percent questions usually break when the base quantity is chosen incorrectly."
    if topic == "ratio":
        return "Why this helps: ratio numbers are usually parts, not the final quantities themselves."
    if topic == "probability":
        return "Why this helps: the numerator and denominator must be counted under the same rules."
    if topic == "statistics":
        return "Why this helps: statistics questions depend on choosing the right measure before calculating."
    if topic == "geometry":
        return "Why this helps: matching the right formula to the shape simplifies the rest of the work."
    return "Why this helps: getting the structure right first makes the next step clearer."


def _tone_rewrite(line: str, tone: float, position: int = 0) -> str:
    text = (line or "").strip()
    if not text:
        return text
    if tone < 0.25:
        return text
    if tone < 0.55:
        return f"Start here: {text[0].lower() + text[1:] if len(text) > 1 else text.lower()}" if position == 0 else text
    if tone < 0.8:
        return f"A good place to start is this: {text[0].lower() + text[1:] if len(text) > 1 else text.lower()}" if position == 0 else text
    return f"You can start with this: {text[0].lower() + text[1:] if len(text) > 1 else text.lower()}" if position == 0 else text


def _transparency_expansion(line: str, topic: str, transparency: float, position: int = 0) -> str:
    text = (line or "").strip()
    if not text or transparency < 0.35:
        return text
    if transparency < 0.7:
        if position == 0:
            if topic == "algebra":
                return f"{text} This keeps the equation balanced while you isolate the variable."
            if topic == "percent":
                return f"{text} This keeps the percent relationship tied to the correct base quantity."
            if topic == "ratio":
                return f"{text} This turns the ratio into usable quantities instead of labels."
            if topic == "probability":
                return f"{text} This separates successful outcomes from total outcomes."
        return text
    if position == 0:
        if topic == "algebra":
            return f"{text} In algebra, each step should preserve an equivalent equation so the solution does not change while the variable is isolated."
        if topic == "percent":
            return f"{text} Percent problems become clearer once the base quantity is fixed, because every percentage must refer back to some amount."
        if topic == "ratio":
            return f"{text} Ratio numbers usually describe relative parts, so turning them into multiples of one common quantity is what makes the setup usable."
        if topic == "probability":
            return f"{text} Probability depends on a consistent sample space, so the numerator and denominator must be counted under the same rules."
        if topic == "statistics":
            return f"{text} Statistics questions often hinge on choosing the right measure first, because different measures capture different features of the data."
        if topic == "geometry":
            return f"{text} Geometry problems often become routine once the correct formula is chosen, because the rest is usually substitution and algebra."
        return f"{text} This makes the underlying structure explicit before you calculate."
    return text


def _styled_lines(lines: List[str], tone: float, transparency: float, topic: str) -> List[str]:
    output: List[str] = []
    for i, line in enumerate(lines):
        rewritten = _tone_rewrite(line, tone, i)
        rewritten = _transparency_expansion(rewritten, topic, transparency, i)
        output.append(rewritten)
    return output


def format_reply(
    core: str,
    tone: float,
    verbosity: float,
    transparency: float,
    help_mode: str,
    hint_stage: int = 0,
    topic: Optional[str] = None,
) -> str:
    prefix = style_prefix(tone)
    core = (core or "").strip()
    if not core:
        return prefix or "Start with the structure of the problem."

    lines = _dedupe_lines(_clean_lines(core))
    if not lines:
        return prefix or "Start with the structure of the problem."

    resolved_topic = _extract_topic_from_text(core, topic)
    normalized_lines = _normalize_display_lines(lines)
    output: List[str] = []
    if prefix:
        output.extend([prefix, ""])

    if help_mode == "hint":
        idx = max(0, min(int(hint_stage or 1) - 1, len(normalized_lines) - 1))
        if verbosity < 0.25:
            shown = [normalized_lines[idx]]
        elif verbosity < 0.62:
            shown = normalized_lines[idx: idx + 2] or [normalized_lines[idx]]
        else:
            shown = normalized_lines[: min(4, len(normalized_lines))]
        shown = _styled_lines(shown, tone, transparency, resolved_topic)
        output.append("Hint:")
        output.extend(f"- {line}" for line in shown)
        if transparency >= 0.75:
            output.extend(["", _why_line(resolved_topic)])
        return "\n".join(output).strip()

    if help_mode in {"walkthrough", "instruction", "step_by_step"}:
        shown = _limit_steps(normalized_lines, verbosity, minimum=2 if help_mode == "walkthrough" else 1)
        shown = _styled_lines(shown, tone, transparency, resolved_topic)
        output.append("Walkthrough:" if help_mode == "walkthrough" else "Step-by-step path:")
        output.extend(f"- {line}" for line in shown)
        if transparency >= 0.7:
            output.extend(["", _why_line(resolved_topic)])
        return "\n".join(output).strip()

    if help_mode in {"method", "explain", "concept", "definition"}:
        shown = _limit_steps(normalized_lines, verbosity, minimum=1)
        shown = _styled_lines(shown, tone, transparency, resolved_topic)
        output.append("Explanation:")
        output.extend(f"- {line}" for line in shown)
        if transparency >= 0.6:
            output.extend(["", _why_line(resolved_topic)])
        return "\n".join(output).strip()

    if help_mode == "answer":
        shown = _limit_steps(normalized_lines, verbosity, minimum=2)
        answer_transparency = transparency if verbosity >= 0.45 else min(transparency, 0.45)
        shown = _styled_lines(shown, tone, answer_transparency, resolved_topic)
        output.append("Answer path:")
        output.extend(f"- {line}" for line in shown)
        if transparency >= 0.75:
            output.extend(["", _why_line(resolved_topic)])
        return "\n".join(output).strip()

    shown = _limit_steps(normalized_lines, verbosity, minimum=1)
    shown = _styled_lines(shown, tone, transparency, resolved_topic)
    output.extend(f"- {line}" for line in shown)
    if transparency >= 0.8:
        output.extend(["", _why_line(resolved_topic)])
    return "\n".join(output).strip()


def format_explainer_response(
    result: Any,
    tone: float,
    verbosity: float,
    transparency: float,
    help_mode: str = "explain",
    hint_stage: int = 0,
) -> str:
    if not result:
        return "I can help explain what the question is asking, but I need the full wording of the question."
    summary = getattr(result, "summary", "") or ""
    teaching_points = getattr(result, "teaching_points", []) or []
    core_lines: List[str] = []
    if isinstance(summary, str) and summary.strip():
        core_lines.append(summary.strip())
    if isinstance(teaching_points, list):
        for item in teaching_points:
            text = str(item).strip()
            if text:
                core_lines.append(text)
    if not core_lines:
        core_lines = ["Start by identifying what the question is asking."]
    return format_reply(
        core="\n".join(core_lines),
        tone=tone,
        verbosity=verbosity,
        transparency=transparency,
        help_mode=help_mode,
        hint_stage=hint_stage,
        topic=getattr(result, "topic", None),
    )