"""PF1e area-shape geometry: cone and line templates on the 5-ft square grid.

PF1e (CRB, Magic — Aiming a Spell):
- "A cone-shaped spell shoots away from you in a quarter-circle in the
  direction you designate. It starts from any corner of your square and
  widens out as it goes." — modeled here as every cell whose center lies
  within the cone's length of the origin and within ±45° of the aim
  direction (a 90°-wide quarter circle), excluding the origin cell.
- "A line-shaped spell shoots away from you in a line in the direction you
  designate. It starts from any corner of your square and extends to the
  limit of its range [...]. A line-shaped spell affects all creatures in
  squares through which the line passes." — modeled here as the 5-ft-wide
  Bresenham ray from the origin through the aim cell, truncated to the
  line's length. The line "starts from any corner of your square", so the
  CASTER's own square is NOT one of the affected squares: the affected
  squares are the ones beyond the origin along the ray (SRD Lightning Bolt:
  "The bolt begins at your fingertips" - it leaves your square, it does not
  fill it). The line also stops at the first square that blocks line of
  effect (CRB, Magic - Aiming a Spell, Line: it "extends to the limit of its
  range or until it strikes a barrier that blocks line of effect"): the
  barrier square is the last square of the template and everything beyond
  it is outside, so a bolt never reaches creatures behind a solid wall.
- Cones require line of effect from their origin (CRB, Magic - Line of
  Effect): "A burst, cone, cylinder, or emanation spell affects only an
  area, creature, or object to which it has line of effect from its origin
  (a spherical burst's center point, a cone-shaped burst's starting
  point, ...)". ``cone_cells`` therefore drops every geometric cell that
  has no corner-to-corner line of effect from the origin square (a solid
  wall between them shields everything behind it).

Bursts need no template here: they are circles around a center cell and are
resolved by ``CombatEngine._area_creatures`` (which additionally drops
creatures without line of effect from the burst's center).
"""

from __future__ import annotations

from typing import TYPE_CHECKING

from pf1e_simulator.los import has_line_of_effect

if TYPE_CHECKING:
    from pf1e_simulator.grid import Grid
    from pf1e_simulator.map import Pos


def cone_cells(
    grid: Grid, origin: Pos, aim: Pos, radius_cells: int
) -> frozenset[Pos]:
    """Cells of a 90° cone of ``radius_cells`` squares starting at ``origin``.

    The cone opens toward ``aim`` (any cell in the aim direction, usually the
    resolved target or point-cast center). A cell is affected when its offset
    from the origin is within ``radius_cells`` (5-10-5 grid distance), points
    strictly into the cone's forward half-plane, and stays within ±45° of the
    aim bearing. The origin cell itself is never affected (CRB: the cone
    "shoots away from you"). A cell with no line of effect from the origin
    is dropped (CRB, Line of Effect: a cone "affects only an area, creature,
    or object to which it has line of effect from its origin" - a solid wall
    stops the cone, it does not pass through). A degenerate aim
    (origin == aim) affects nothing.

    The ±45° test is exact integer arithmetic: with v the cell offset and d
    the aim offset, ``cos(angle) >= cos(45°)`` is equivalent to
    ``2 * (v·d)^2 >= |v|^2 * |d|^2`` together with ``v·d > 0``.
    """
    d_row = aim[0] - origin[0]
    d_col = aim[1] - origin[1]
    if d_row == 0 and d_col == 0:
        return frozenset()
    aim_sq = d_row * d_row + d_col * d_col
    cells: set[Pos] = set()
    for row in range(origin[0] - radius_cells, origin[0] + radius_cells + 1):
        for col in range(origin[1] - radius_cells, origin[1] + radius_cells + 1):
            cell = (row, col)
            if cell == origin or not grid.in_bounds(cell):
                continue
            v_row = row - origin[0]
            v_col = col - origin[1]
            dot = v_row * d_row + v_col * d_col
            if dot <= 0:
                continue
            if 2 * dot * dot < (v_row * v_row + v_col * v_col) * aim_sq:
                continue
            if grid.distance(origin, cell) > radius_cells:
                continue
            if not has_line_of_effect(grid, origin, cell):
                continue
            cells.add(cell)
    return frozenset(cells)


def line_cells(
    grid: Grid, origin: Pos, aim: Pos, length_cells: int
) -> frozenset[Pos]:
    """Cells of a 5-ft-wide line of ``length_cells`` squares from ``origin``.

    The line runs along the Bresenham ray from the origin toward ``aim``,
    extended to ``length_cells`` squares (CRB: it "extends to the limit of
    its range"). The line "starts from any corner of your square" (CRB, Magic
    - Aiming a Spell), so the CASTER's own square is NOT affected: the
    ``length_cells`` affected squares are the ones *beyond* the origin along
    the ray. Out-of-bounds cells simply drop out of the template (creatures
    only exist in bounds). The ray stops at the first cell that blocks line
    of effect (CRB, Line: "or until it strikes a barrier that blocks line of
    effect") - the barrier cell itself is the last cell of the template (the
    line strikes it) and everything beyond it is excluded. A
    degenerate aim (origin == aim) affects nothing.
    """
    if length_cells <= 0:
        return frozenset()
    d_row = aim[0] - origin[0]
    d_col = aim[1] - origin[1]
    if d_row == 0 and d_col == 0:
        return frozenset()
    # Extend the aim vector so the ray reaches `length_cells` squares BEYOND
    # the origin (the dominant-axis step count of a Bresenham line is
    # max(|d_row|, |d_col|)); the +1 accounts for the origin square we drop.
    scale = (length_cells + 1) / max(abs(d_row), abs(d_col))
    end = (origin[0] + round(d_row * scale), origin[1] + round(d_col * scale))
    # The line is `length_cells` squares LONG starting just past the caster:
    # 120 ft / 5 ft = 24 squares, none of them the caster's own (SRD Lightning
    # Bolt: "The bolt begins at your fingertips" — it leaves your square).
    ray = _bresenham(origin, end)
    cells: list[Pos] = []
    for cell in ray[1 : length_cells + 1]:
        if not grid.in_bounds(cell):
            continue
        cells.append(cell)
        if grid.terrain_at(cell).blocks_los:
            break
    return frozenset(cells)


def _bresenham(start: Pos, end: Pos) -> list[Pos]:
    """Inclusive Bresenham cell list from ``start`` to ``end`` (both ends kept)."""
    row, col = start
    end_row, end_col = end
    d_row = abs(end_row - row)
    d_col = abs(end_col - col)
    step_row = 1 if row < end_row else -1
    step_col = 1 if col < end_col else -1
    err = d_row - d_col
    cells: list[Pos] = [(row, col)]
    while (row, col) != (end_row, end_col):
        e2 = 2 * err
        if e2 > -d_col:
            err -= d_col
            row += step_row
        if e2 < d_row:
            err += d_row
            col += step_col
        cells.append((row, col))
    return cells