from __future__ import annotations

import ctypes
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Iterable, List

import numpy as np
from numpy.lib.format import open_memmap
from tqdm import tqdm

from .embeddings import l2_normalize


@dataclass
class FLAREMolEmbedder:
    flare_repo: str
    hparams_pth: str
    checkpoint_pth: str
    device: str = "cpu"
    batch_size: int = 256
    normalize: bool = True

    def _load(self):
        libstdcpp = Path(sys.executable).resolve().parent.parent / "lib" / "libstdc++.so.6"
        if libstdcpp.exists():
            ctypes.CDLL(str(libstdcpp), mode=ctypes.RTLD_GLOBAL)

        import dgl
        import torch
        import yaml

        flare_repo = Path(self.flare_repo).resolve()
        if str(flare_repo) not in sys.path:
            sys.path.insert(0, str(flare_repo))

        from flare.data.transforms import MolToGraph
        from flare.utils.models import get_model

        with open(self.hparams_pth) as f:
            params = yaml.load(f, Loader=yaml.FullLoader)
        params["checkpoint_pth"] = str(self.checkpoint_pth)
        params["df_test_path"] = ""
        params["accelerator"] = "cpu"
        params["devices"] = 1

        device = self.device
        if device == "cuda":
            if not torch.cuda.is_available():
                device = "cpu"
            else:
                try:
                    dgl.graph(([0], [0])).to("cuda")
                except Exception:
                    device = "cpu"

        model = get_model(params["model"], params)
        model = model.to(device)
        model.eval()

        mol_transform = MolToGraph(
            atom_feature=params["atom_feature"],
            bond_feature=params["bond_feature"],
            element_list=params["element_list"],
        )
        return model.mol_enc_model, mol_transform, device

    def encode(self, smiles: Iterable[str]) -> np.ndarray:
        import dgl
        import torch

        smiles_list = list(smiles)
        if not smiles_list:
            return np.zeros((0, 0), dtype=np.float32)

        mol_encoder, mol_transform, device = self._load()
        outputs: List[np.ndarray] = []
        total_batches = (len(smiles_list) + self.batch_size - 1) // self.batch_size

        with torch.no_grad():
            for start in tqdm(range(0, len(smiles_list), self.batch_size), total=total_batches, desc="Encoding FLARE", unit="batch"):
                batch_smiles = smiles_list[start:start + self.batch_size]
                graphs = [mol_transform(smi) for smi in batch_smiles]
                batched = dgl.batch(graphs)
                if device != "cpu":
                    batched = batched.to(device)
                node_embeddings = mol_encoder(batched)
                pooled = mol_encoder.pool(batched, node_embeddings)
                outputs.append(pooled.detach().cpu().numpy().astype(np.float32))

        arr = np.concatenate(outputs, axis=0).astype(np.float32)
        if self.normalize:
            arr = l2_normalize(arr)
        return arr

    def encode_to_npy(self, smiles: Iterable[str], out_path: str | Path) -> Path:
        import dgl
        import torch

        smiles_list = list(smiles)
        out_path = Path(out_path)
        if not smiles_list:
            np.save(out_path, np.zeros((0, 0), dtype=np.float32))
            return out_path

        mol_encoder, mol_transform, device = self._load()
        total_batches = (len(smiles_list) + self.batch_size - 1) // self.batch_size
        mm = None
        offset = 0

        with torch.no_grad():
            for start in tqdm(range(0, len(smiles_list), self.batch_size), total=total_batches, desc="Encoding FLARE", unit="batch"):
                batch_smiles = smiles_list[start:start + self.batch_size]
                graphs = [mol_transform(smi) for smi in batch_smiles]
                batched = dgl.batch(graphs)
                if device != "cpu":
                    batched = batched.to(device)
                node_embeddings = mol_encoder(batched)
                pooled = mol_encoder.pool(batched, node_embeddings)
                chunk = pooled.detach().cpu().numpy().astype(np.float32)
                if mm is None:
                    mm = open_memmap(out_path, mode="w+", dtype=np.float32, shape=(len(smiles_list), chunk.shape[1]))
                mm[offset:offset + chunk.shape[0]] = chunk
                offset += chunk.shape[0]

        if mm is None:
            np.save(out_path, np.zeros((0, 0), dtype=np.float32))
            return out_path
        del mm

        if self.normalize:
            arr = np.load(out_path, mmap_mode="r+")
            norms = np.linalg.norm(arr, axis=1, keepdims=True)
            arr[:] = arr[:] / np.clip(norms, 1e-8, None)
            del arr
        return out_path


@dataclass
class FLARESpecEmbedder:
    flare_repo: str
    hparams_pth: str
    checkpoint_pth: str
    dataset_pth: str
    subformula_dir_pth: str
    fold: str = "test"
    device: str = "cpu"
    batch_size: int = 128
    normalize: bool = True

    def _load(self):
        libstdcpp = Path(sys.executable).resolve().parent.parent / "lib" / "libstdc++.so.6"
        if libstdcpp.exists():
            ctypes.CDLL(str(libstdcpp), mode=ctypes.RTLD_GLOBAL)

        import dgl
        import torch
        import yaml

        flare_repo = Path(self.flare_repo).resolve()
        if str(flare_repo) not in sys.path:
            sys.path.insert(0, str(flare_repo))

        from massspecgym.models.base import Stage
        from flare.data.datasets import MassSpecDataset_PeakFormulas
        from flare.utils.data import get_spec_featurizer
        from flare.utils.models import get_model

        with open(self.hparams_pth) as f:
            params = yaml.load(f, Loader=yaml.FullLoader)
        params["checkpoint_pth"] = str(self.checkpoint_pth)
        params["df_test_path"] = ""
        params["accelerator"] = "cpu"
        params["devices"] = 1

        device = self.device
        if device == "cuda":
            if not torch.cuda.is_available():
                device = "cpu"
            else:
                try:
                    dgl.graph(([0], [0])).to("cuda")
                except Exception:
                    device = "cpu"

        model = get_model(params["model"], params)
        model = model.to(device)
        model.eval()

        spec_transform = get_spec_featurizer(params["spectra_view"], params)
        dataset = MassSpecDataset_PeakFormulas(
            spectra_view=params["spectra_view"],
            spec_transform=spec_transform,
            mol_transform=None,
            pth=self.dataset_pth,
            subformula_dir_pth=self.subformula_dir_pth,
            formula_source=params.get("formula_source", "default"),
            return_mol_freq=False,
            return_identifier=True,
            stage=Stage.TEST,
        )
        return model.spec_enc_model, params["spectra_view"], dataset, device

    def encode(self):
        import torch

        spec_encoder, spectra_view, dataset, device = self._load()
        metadata = dataset.metadata
        if "fold" in metadata.columns and self.fold:
            metadata = metadata[metadata["fold"].astype(str) == str(self.fold)]
        indices = metadata.index.to_list()

        if not indices:
            return np.zeros((0, 0), dtype=np.float32), [], []

        outputs: List[np.ndarray] = []
        out_smiles: List[str] = []
        out_ids: List[str] = []

        with torch.no_grad():
            for start in tqdm(range(0, len(indices), self.batch_size), desc="Encoding FLARE spectra", unit="batch"):
                batch_idx = indices[start:start + self.batch_size]
                specs = []
                n_peaks = []
                for idx in batch_idx:
                    item = dataset.__getitem__(idx, transform_mol=False)
                    spec = item[spectra_view]
                    specs.append(spec)
                    n_peaks.append(int(spec.shape[0]))
                    row = dataset.metadata.loc[idx]
                    out_smiles.append(str(row["smiles"]))
                    out_ids.append(str(row["identifier"]))
                batch = torch.nn.utils.rnn.pad_sequence(specs, batch_first=True, padding_value=-5)
                batch = batch.to(device)
                enc = spec_encoder(batch, n_peaks)
                if enc.ndim == 3:
                    mask = (batch != -5).any(dim=-1).float()
                    pooled = (enc * mask.unsqueeze(-1)).sum(dim=1) / mask.sum(dim=1, keepdim=True).clamp(min=1.0)
                else:
                    pooled = enc
                outputs.append(pooled.detach().cpu().numpy().astype(np.float32))

        arr = np.concatenate(outputs, axis=0).astype(np.float32)
        if self.normalize:
            arr = l2_normalize(arr)
        return arr, out_smiles, out_ids