"""Task 2's prompt: the design described in words instead of shown as an image.

The description is generated from the ground-truth document, so it is exactly
as informative as intended and never hallucinates: every asset and every word
of copy is named, colours and fonts are given, and placement is coarse, in the
vocabulary a designer would use in a brief ("top left", "centred", "large").
The model has to turn that into coordinates, which is the skill the task tests.
"""

from __future__ import annotations

from .colors import color_name
from .doc import DesignDoc, Element


def _where(el: Element, doc: DesignDoc) -> str:
    x0, y0 = max(0.0, el.x), max(0.0, el.y)
    x1, y1 = min(doc.width, el.x + el.width), min(doc.height, el.y + el.height)
    if x1 <= x0 or y1 <= y0:
        return "mostly off the canvas"
    cover_w = (x1 - x0) / doc.width
    cover_h = (y1 - y0) / doc.height
    if cover_w > 0.9 and cover_h > 0.9:
        return "covering the whole canvas"
    cx = (x0 + x1) / 2 / doc.width
    cy = (y0 + y1) / 2 / doc.height
    col = "left" if cx < 0.36 else "right" if cx > 0.64 else "center"
    row = "top" if cy < 0.36 else "bottom" if cy > 0.64 else "middle"
    if cover_w > 0.9:
        return {"top": "across the top", "middle": "across the middle",
                "bottom": "across the bottom"}[row]
    if cover_h > 0.9:
        return {"left": "down the left side", "center": "down the middle",
                "right": "down the right side"}[col]
    if row == "middle" and col == "center":
        return "in the center"
    if col == "center":
        return f"at the {row} center"
    if row == "middle":
        return f"at the middle {col}"
    return f"at the {row} {col}"


def _size(el: Element, doc: DesignDoc) -> str:
    frac = (el.width * el.height) / (doc.width * doc.height)
    if frac > 0.6:
        return "full-bleed"
    if frac > 0.25:
        return "large"
    if frac > 0.07:
        return "medium"
    if frac > 0.015:
        return "small"
    return "tiny"


def _text_size(el: Element, doc: DesignDoc) -> str:
    rel = el.font_size / doc.height
    if rel > 0.12:
        return "huge"
    if rel > 0.06:
        return "large"
    if rel > 0.03:
        return "medium"
    return "small"


def describe(doc: DesignDoc, meta: dict, asset_meta: dict[str, dict]) -> str:
    fmt = meta.get("format") or "design"
    title = meta.get("title") or ""
    head = f"A {fmt} design, {doc.width}x{doc.height}px"
    if title:
        head += f', titled "{title}"'
    lines = [head + "."]
    lines.append(
        f"Background colour: {color_name(doc.background)} ({doc.background})."
    )
    lines.append("Layers from back to front:")
    for n, el in enumerate(doc.elements, 1):
        where = _where(el, doc)
        if el.kind == "image":
            kind = asset_meta.get(el.asset_id, {}).get("kind", "image")
            noun = {"photo": "photo", "graphic": "graphic", "background": "background texture"}.get(
                kind, "image"
            )
            desc = f"{n}. A {_size(el, doc)} {noun} (asset {el.asset_id}) {where}"
        elif el.kind == "shape":
            desc = f"{n}. A {el.shape} in {color_name(el.fill or '#000000')} {where}"
        else:
            text = el.display_text().replace("\n", " / ")
            style = []
            if el.bold:
                style.append("bold")
            if el.italic:
                style.append("italic")
            color = el.color or "#000000"
            desc = (
                f'{n}. Text "{text}" in {" ".join(style + [el.font_family or ""]).strip()}, '
                f"{_text_size(el, doc)} ({el.font_size:.0f}px), {color_name(color)} ({color}), "
                f"{el.align}-aligned, {where}"
            )
            if el.letter_spacing and abs(el.letter_spacing) >= 0.5:
                desc += f", letter-spacing {el.letter_spacing:.0f}px"
            if len(el.lines) > 1:
                desc += f", {len(el.lines)} lines"
            if el.runs:
                colors = sorted({color_name(r.color) for r in el.styled_runs() if r.text.strip()})
                if len(colors) > 1:
                    desc += f" (mixed colours: {', '.join(colors)})"
        if el.angle:
            desc += f", rotated {el.angle:.0f} degrees"
        if el.opacity < 0.95:
            desc += f", {round(el.opacity * 100)}% opacity"
        lines.append(desc + ".")
    keywords = [k for k in (meta.get("keywords") or [])][:8]
    if keywords:
        lines.append(f"Mood / keywords: {', '.join(keywords)}.")
    return "\n".join(lines)