from __future__ import annotations

from pathlib import Path
from typing import Dict, List, Sequence

import numpy as np
from Bio.PDB.Polypeptide import protein_letters_3to1

from libs.utils.io_pdb import load_structure

from .schemas import LigandGraph, ProteinGraph


def build_ligand_graph(mol) -> LigandGraph:
    """Build atom-level graph from an RDKit Mol object."""
    atom_features: List[List[float]] = []
    for atom in mol.GetAtoms():
        atom_features.append(
            [
                float(atom.GetAtomicNum()),
                float(atom.GetTotalDegree()),
                float(atom.GetFormalCharge()),
                float(atom.GetIsAromatic()),
                float(atom.GetMass()),
            ]
        )

    edges: List[List[int]] = []
    edge_features: List[List[float]] = []
    for bond in mol.GetBonds():
        i = bond.GetBeginAtomIdx()
        j = bond.GetEndAtomIdx()
        btype = float(bond.GetBondTypeAsDouble())
        ring = float(bond.IsInRing())
        edges.extend([[i, j], [j, i]])
        edge_features.extend([[btype, ring], [btype, ring]])

    if not edges:
        edge_index = np.zeros((2, 0), dtype=int)
        edge_attr = np.zeros((0, 2), dtype=float)
    else:
        edge_index = np.asarray(edges, dtype=int).T
        edge_attr = np.asarray(edge_features, dtype=float)

    node = np.asarray(atom_features, dtype=float) if atom_features else np.zeros((0, 5), dtype=float)
    return LigandGraph(node_features=node, edge_index=edge_index, edge_features=edge_attr)


def _residue_name_to_one_letter(resname: str) -> str:
    return protein_letters_3to1.get(resname.upper(), "X")


def build_protein_graph(structure_path: str | Path, distance_threshold: float = 8.0, pocket_residues: Sequence[str] | None = None) -> ProteinGraph:
    """Build residue-level graph with distance-threshold edges."""
    structure = load_structure(structure_path)
    residues = [r for r in structure.get_residues() if r.id[0] == " "]

    coords = []
    node_features = []
    node_labels: List[str] = []
    pocket_set = set(pocket_residues or [])

    for residue in residues:
        chain = residue.get_parent().id
        idx = residue.id[1]
        label = f"{chain}:{idx}"
        ca = residue["CA"].coord if "CA" in residue else None
        if ca is None:
            atoms = [atom.coord for atom in residue.get_atoms()]
            ca = np.mean(np.asarray(atoms, dtype=float), axis=0) if atoms else np.zeros(3, dtype=float)

        aa = _residue_name_to_one_letter(residue.resname)
        aa_index = float(ord(aa) - ord("A")) if aa.isalpha() else -1.0
        node_features.append(
            [
                float(idx),
                aa_index,
                float(label in pocket_set),
            ]
        )
        coords.append(np.asarray(ca, dtype=float))
        node_labels.append(label)

    if not coords:
        return ProteinGraph(node_features=np.zeros((0, 3)), edge_index=np.zeros((2, 0), dtype=int), node_labels=[])

    xyz = np.vstack(coords)
    n = xyz.shape[0]
    edges: List[List[int]] = []
    for i in range(n):
        for j in range(i + 1, n):
            dist = float(np.linalg.norm(xyz[i] - xyz[j]))
            if dist <= distance_threshold:
                edges.extend([[i, j], [j, i]])

    edge_index = np.asarray(edges, dtype=int).T if edges else np.zeros((2, 0), dtype=int)
    return ProteinGraph(node_features=np.asarray(node_features, dtype=float), edge_index=edge_index, node_labels=node_labels)


def protein_sequence_from_structure(structure_path: str | Path) -> str:
    """Derive a rough sequence by concatenating residue symbols from the first model."""
    structure = load_structure(structure_path)
    residues = [r for r in structure.get_residues() if r.id[0] == " "]
    return "".join(_residue_name_to_one_letter(r.resname) for r in residues)