"""
PCAScGPTExtractor — Projects FrozenScGPTExtractor output onto
the first n_dims principal components of scGPT gene embeddings.

Instead of slicing the first n_dims (arbitrary), PCA captures the
dominant variation direction in gene embedding space:
    gene_proj = PCA(gene_emb, n_dims)   # (G, 1)
    features  = delta_attn @ gene_proj  # (B, G, 1)
"""

import torch
import torch.nn as nn


class PCAScGPTExtractor(nn.Module):

    def __init__(self, base_extractor, n_dims: int = 1):
        super().__init__()
        self.base = base_extractor
        self.n_dims = n_dims
        self.scgpt_d_model = n_dims
        self.n_hvg = base_extractor.n_hvg
        self._pca_V = None  # (512, n_dims), computed lazily

    @torch.no_grad()
    def _ensure_pca(self, device):
        if self._pca_V is not None:
            return
        valid_ids = self.base.hvg_to_scgpt_id[self.base.hvg_to_scgpt_id >= 0]
        gene_emb = self.base.scgpt_model.encoder(
            valid_ids.unsqueeze(0).to(device)
        ).squeeze(0)  # (G_valid, 512)

        centered = gene_emb - gene_emb.mean(dim=0)
        U, S, V = torch.pca_lowrank(centered, q=max(self.n_dims, 6))
        self._pca_V = V[:, :self.n_dims].to(device)  # (512, n_dims)

        explained = (S[:self.n_dims] ** 2).sum() / (centered ** 2).sum()
        print(f"[PCA] gene_emb: {self.base.scgpt_d_model}D -> {self.n_dims}D, "
              f"explained variance: {explained:.4f}")

    def extract(self, expression_values, gene_indices=None):
        z = self.base.extract(expression_values, gene_indices)  # (B, G, 512)
        self._ensure_pca(z.device)
        return torch.matmul(z, self._pca_V)  # (B, G, n_dims)

    def extract_attention_delta(self, control_expr, target_expr,
                                gene_indices=None, attn_layer=11,
                                use_rank_norm=True, multi_layer=""):
        z = self.base.extract_attention_delta(
            control_expr, target_expr, gene_indices,
            attn_layer, use_rank_norm, multi_layer,
        )  # (B, G, 512)
        self._ensure_pca(z.device)
        return torch.matmul(z, self._pca_V)  # (B, G, n_dims)

    def get_missing_gene_mask(self, gene_indices=None):
        return self.base.get_missing_gene_mask(gene_indices)

    def train(self, mode=True):
        super().train(mode)
        self.base.train(mode)
        return self