import torch
import torch.nn.functional as F
from training.misc import is_main_process
import torch


class DeCLIP:
    def __call__(self, batch, student, teacher, vfm_model, args):
        losses={}
        context_weight = args.loss_context_weight
        content_weight = args.loss_content_weight
        if args.distributed:
            student = student.module
        dtype_map = {"bf16": torch.bfloat16, "amp": torch.float16}
        input_dtype = dtype_map.get(args.precision, torch.float32)
        images, normed_boxes, image_crops, proxy_image = batch
        images = images.to(device=args.device, dtype=input_dtype, non_blocking=True)  
        normed_boxes = normed_boxes.to(device=args.device, dtype=input_dtype,non_blocking=True)
        image_crops = image_crops.to(device=args.device, dtype=input_dtype,non_blocking=True) 
        proxy_image=proxy_image.to(device=args.device, dtype=input_dtype, non_blocking=True)

        rois_list = []
        crops_list = []
        for bboxes_per_image, crops_per_image in zip(normed_boxes, image_crops):
            valid = bboxes_per_image[:, -1] > 0.5
            rois_list.append(bboxes_per_image[valid, :4])
            crops_list.append(crops_per_image[valid])
        image_crops = torch.cat(crops_list)
        student_roi_features, context = student.encode_pseudo_boxes(images, rois_list, normalize=True, mode = args.mode)

        with torch.no_grad():
            teacher_crop_features = teacher.encode_image(image_crops, normalize=True)
            if args.use_vfm:
                teacher_context_similarity, teacher_h, teacher_w = self.get_teacher_context_similarity(vfm_model,proxy_image,args)
            else:
                teacher_context_similarity=teacher_h = teacher_w=None

        if args.use_vfm:
            student_context_similarity=self.get_student_context_similarity(images, context,teacher_h,teacher_w, args)
            _loss_context=(teacher_context_similarity - student_context_similarity).norm(p=2,dim=-1).mean() 
            losses.update({"loss_context":_loss_context*context_weight})

        _loss_content = 1.0 - (student_roi_features * teacher_crop_features).sum(-1).mean()
        losses.update({"loss_content":_loss_content * content_weight})
        return losses, len(images)

    def get_teacher_context_similarity(self,vfm_model,proxy_image,args):
        if 'sam' in args.use_vfm:
            vfm_feats=vfm_model.image_encoder(proxy_image)
        elif "dinov2" in args.use_vfm:
            vfm_feats = vfm_model.get_intermediate_layers(proxy_image, reshape=True)[0]
        elif 'dino' in args.use_vfm:
            feat = vfm_model.get_intermediate_layers(proxy_image)[0]
            nb_im = feat.shape[0]
            patch_size = vfm_model.patch_embed.patch_size
            I, J = proxy_image[0].shape[-2] // patch_size, proxy_image[0].shape[-2] // patch_size
            vfm_feats = feat[:, 1:, :].reshape(nb_im, I, J, -1).permute(0, 3, 1, 2)
        else:
                raise NotImplementedError(f"mode {args.use_vfm} is not implemented yet.")
        teacher_h,teacher_w=vfm_feats.shape[-2:]
        vfm_feats= F.normalize(vfm_feats.flatten(-2,-1), dim=1)
        vfm_similarity = torch.einsum("b c m, b c n -> b m n", vfm_feats, vfm_feats)
        return vfm_similarity,teacher_h,teacher_w
    
    def get_student_context_similarity(self,images,context,teacher_h,teacher_w,args):
        B = images.shape[0]
        if args.mode in ["qq_vfm_distill","kk_vfm_distill","vv_vfm_distill","sanity_check"]:
            N, _ = context.shape[1:]
            context=context.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
            bs, N, C = context.shape
            n_sqrt = int(N ** 0.5)
            if n_sqrt != teacher_h or n_sqrt != teacher_w:
                context_reshaped = context.transpose(-2,-1).contiguous().view(bs, C, n_sqrt, n_sqrt)
                context_resized = F.interpolate(context_reshaped, size=(teacher_h, teacher_w), mode='bilinear', align_corners=False)
                context = context_resized.transpose(-2,-1).contiguous().view(bs, teacher_h * teacher_w, C)
            context = F.normalize(context, dim=-1).transpose(-2,-1)
            student_context_similarity=torch.einsum("b c m, b c n -> b m n", context, context)
        elif args.mode == "csa_vfm_distill":
            q_feature, k_feature = context
            N, _ = q_feature.shape[1:]
            q_feature = q_feature.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
            k_feature = k_feature.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
            q_feature = F.normalize(q_feature, dim=-1).transpose(-2,-1)
            k_feature = F.normalize(k_feature, dim=-1).transpose(-2,-1)
            student_context_similarity=(torch.einsum("b c m, b c n -> b m n", q_feature, q_feature)+torch.einsum("b c m, b c n -> b m n", k_feature, k_feature))/2.0
        elif args.mode == "all_vfm_distill": 
            q_feature, k_feature, v_feature = context
            q_feature = F.normalize(q_feature, dim=-1).transpose(-2,-1)
            k_feature = F.normalize(k_feature, dim=-1).transpose(-2,-1)
            v_feature = F.normalize(v_feature, dim=-1).transpose(-2,-1)
            student_context_similarity=(torch.einsum("b c m, b c n -> b m n", q_feature, q_feature)+
                                    torch.einsum("b c m, b c n -> b m n", k_feature, k_feature)+
                                    torch.einsum("b c m, b c n -> b m n", v_feature, v_feature))/3.0
           
        else:
            raise NotImplementedError(f"Mode '{args.mode}' is not implemented.")
        return student_context_similarity