"""Compute exact shortest 30-degree action paths for generated task poses."""

from __future__ import annotations

import math
from collections import deque
from typing import Any, Iterable

import numpy as np

from benchmark_core import Pose, _euler_to_matrix, _mat_mul, _rot_x, _rot_y, _rot_z


ACTIONS = (
    "PITCH_POS",
    "PITCH_NEG",
    "YAW_POS",
    "YAW_NEG",
    "ROLL_POS",
    "ROLL_NEG",
)
INVERSE_ACTION = {
    "PITCH_POS": "PITCH_NEG",
    "PITCH_NEG": "PITCH_POS",
    "YAW_POS": "YAW_NEG",
    "YAW_NEG": "YAW_POS",
    "ROLL_POS": "ROLL_NEG",
    "ROLL_NEG": "ROLL_POS",
}


def _flatten(matrix: tuple[tuple[float, ...], ...]) -> tuple[float, ...]:
    return tuple(value for row in matrix for value in row)


def _state_key(matrix: tuple[tuple[float, ...], ...]) -> tuple[int, ...]:
    return tuple(round(value * 1_000_000_000) for value in _flatten(matrix))


def _delta_matrices(theta: int) -> dict[str, tuple[tuple[float, ...], ...]]:
    return {
        "PITCH_POS": _rot_x(theta),
        "PITCH_NEG": _rot_x(-theta),
        "YAW_POS": _rot_y(theta),
        "YAW_NEG": _rot_y(-theta),
        "ROLL_POS": _rot_z(theta),
        "ROLL_NEG": _rot_z(-theta),
    }


def matrix_from_actions(actions: Iterable[str], theta: int = 30):
    matrix = _euler_to_matrix(0.0, 0.0, 0.0)
    deltas = _delta_matrices(theta)
    for action in actions:
        matrix = _mat_mul(deltas[action], matrix)
    return matrix


def matrix_error(left, right) -> float:
    return max(abs(a - b) for a, b in zip(_flatten(left), _flatten(right)))


def bfs_distances_for_tasks(
    tasks: list[dict[str, Any]], theta: int = 30
) -> tuple[dict[str, int], dict[str, Any]]:
    """Find exact distances by intersecting two radius-eight BFS balls."""
    targets: dict[str, tuple[tuple[float, ...], ...]] = {}
    upper_bounds: dict[str, int] = {}
    pose_errors: dict[str, float] = {}
    max_scramble_len = 0
    for task in tasks:
        sample_id = str(task["sample_id"])
        actions = [str(action) for action in task["scramble_actions"]]
        if int(task["theta"]) != theta:
            raise ValueError(f"{sample_id}: expected theta={theta}")
        generated = matrix_from_actions(actions, theta)
        stored = _euler_to_matrix(**{
            "roll_deg": float(task["init_pose"]["roll"]),
            "pitch_deg": float(task["init_pose"]["pitch"]),
            "yaw_deg": float(task["init_pose"]["yaw"]),
        })
        error = matrix_error(generated, stored)
        if error > 2e-8:
            raise ValueError(f"{sample_id}: stored pose differs from scramble path by {error}")
        pose_errors[sample_id] = error
        targets[sample_id] = generated
        upper_bounds[sample_id] = len(actions)
        max_scramble_len = max(max_scramble_len, upper_bounds[sample_id])

    identity = _euler_to_matrix(0.0, 0.0, 0.0)
    identity_key = _state_key(identity)
    queue = deque([(identity, 0, "")])
    visited = {identity_key: 0}
    matrices = [identity]
    depths = [0]
    depth_counts: dict[int, int] = {}
    deltas = _delta_matrices(theta)
    radius = math.ceil(max_scramble_len / 2)

    while queue:
        matrix, depth, previous_action = queue.popleft()
        depth_counts[depth] = depth_counts.get(depth, 0) + 1
        if depth >= radius:
            continue
        for action in ACTIONS:
            if previous_action and action == INVERSE_ACTION[previous_action]:
                continue
            nxt = _mat_mul(deltas[action], matrix)
            nxt_key = _state_key(nxt)
            if nxt_key in visited:
                continue
            visited[nxt_key] = depth + 1
            matrices.append(nxt)
            depths.append(depth + 1)
            queue.append((nxt, depth + 1, action))

    matrix_array = np.asarray(matrices, dtype=np.float64)
    depth_array = np.asarray(depths, dtype=np.int16)
    key_array = np.rint(matrix_array.reshape(-1, 9) * 1_000_000_000).astype(np.int64)
    row_dtype = np.dtype((np.void, key_array.dtype.itemsize * key_array.shape[1]))
    key_rows = np.ascontiguousarray(key_array).view(row_dtype).reshape(-1)
    order = np.argsort(key_rows)
    sorted_rows = key_rows[order]
    sorted_depths = depth_array[order]

    distances: dict[str, int] = {}
    for sample_id in sorted(targets):
        upper = upper_bounds[sample_id]
        source_radius = upper // 2
        target_radius = upper - source_radius
        source_indices = np.flatnonzero(depth_array <= source_radius)
        target = np.asarray(targets[sample_id], dtype=np.float64)
        best = upper + 1
        for start in range(0, len(source_indices), 50_000):
            indices = source_indices[start : start + 50_000]
            transformed = np.matmul(target, np.transpose(matrix_array[indices], (0, 2, 1)))
            transformed_keys = np.rint(transformed.reshape(-1, 9) * 1_000_000_000).astype(np.int64)
            query_rows = np.ascontiguousarray(transformed_keys).view(row_dtype).reshape(-1)
            positions = np.searchsorted(sorted_rows, query_rows)
            valid = positions < len(sorted_rows)
            safe_positions = np.minimum(positions, len(sorted_rows) - 1)
            valid &= sorted_rows[safe_positions] == query_rows
            valid &= sorted_depths[safe_positions] <= target_radius
            if np.any(valid):
                totals = depth_array[indices[valid]] + sorted_depths[safe_positions[valid]]
                best = min(best, int(np.min(totals)))
        if best > upper:
            raise RuntimeError(f"No bidirectional BFS intersection for {sample_id} within {upper} steps")
        distances[sample_id] = best

    metadata = {
        "algorithm": "exact bidirectional breadth-first search",
        "state": "3x3 observer-frame rotation matrix quantized to 1e-9",
        "target": "exact target orientation (identity for canonical tasks)",
        "theta_degrees": theta,
        "actions": list(ACTIONS),
        "inverse-action_pruning": True,
        "search_depth_limit_per_side": radius,
        "task_upper_bound": "length of verified generated scramble path (6-16)",
        "visited_state_count": len(visited),
        "expanded_state_count_by_depth": {str(k): v for k, v in sorted(depth_counts.items())},
        "max_stored_pose_matrix_error": max(pose_errors.values()),
    }
    return distances, metadata