import torch
import torch.nn.functional as F

def lsc_torch(probs: torch.Tensor, w: torch.Tensor):
    """
    GPU-compatible LSC implementation
    probs: Tensor [N, C]
    w: Tensor [C]
    """
    assert probs.shape[-1] == w.shape[0], "Shape mismatch"

    weighted_probs = probs * w
    pc_probs = F.normalize(weighted_probs, p=1, dim=-1)
    return pc_probs
def get_py_torch(probs: torch.Tensor, cls_num_list=None, mode='soft'):
    """
    GPU-compatible estimation of P(Y_s=i)
    probs: Tensor [N, C]
    """
    cls_num = probs.shape[-1]

    if mode == "soft":
        py = torch.mean(probs, dim=0)
    elif mode == "hard":
        preds = torch.argmax(probs, dim=-1)
        py = torch.bincount(preds, minlength=cls_num).float()
        py = py / py.sum()
    elif mode == 'gt' and cls_num_list is not None:
        py = torch.tensor(cls_num_list, dtype=torch.float32, device=probs.device)
        py = py / py.sum()
    else:
        raise ValueError("mode must be 'soft', 'hard', or 'gt'")

    return py
def get_marginal_torch(probs: torch.Tensor, cls_num: int, mode='soft'):
    assert probs.shape[-1] == cls_num
    if mode == 'hard':
        pred = torch.argmax(probs, dim=-1)
        qz = torch.bincount(pred, minlength=cls_num).float()
        qz = qz / qz.sum()
    elif mode == 'soft':
        qz = torch.mean(probs, dim=0)
    return qz
def get_confusion_matrix_torch(probs: torch.Tensor, labels: torch.Tensor, cls_num: int, mode='soft'):
    """
    probs: Tensor [N, C]
    labels: Tensor [N] (long)
    returns: [cls_num, cls_num] confusion matrix
    """
    cm = torch.zeros((cls_num, cls_num), device=probs.device)
    if mode == 'soft':
        for i in range(len(labels)):
            cm[labels[i]] += probs[i]
    elif mode == 'hard':
        pred = torch.argmax(probs, dim=-1)
        for i in range(len(labels)):
            cm[labels[i], pred[i]] += 1
    return cm
def normalized_torch(a: torch.Tensor, axis=-1, order=2):
    norm = torch.norm(a, p=order, dim=axis, keepdim=True)
    norm[norm == 0] = 1.0
    return a / norm
def topk_qy_torch(probs: torch.Tensor, cls_num: int, topk_ratio=0.8, head=0, normalize=True):
    """
    probs: Tensor [N, C]
    return: Tensor [C]
    """
    N, C = probs.shape
    k = max(min(int(cls_num * topk_ratio) + head, cls_num), head + 1)

    qy = torch.zeros(cls_num, device=probs.device)
    topk_vals, topk_indices = torch.topk(probs, k=k, dim=1)

    for i in range(N):
        qy[topk_indices[i][head:]] += topk_vals[i][head:]

    if normalize:
        qy = qy / N

    return qy