import os
import math
import torch
import folder_paths
import comfy.utils
import comfy.lora

class GLoKRLoaderNode:
    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "model": ("MODEL",),
                "clip": ("CLIP",),
                "lora_name": (folder_paths.get_filename_list("loras"),),
                "strength_model": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
                "strength_clip": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
                "rs_lora": ("BOOLEAN", {"default": False}),
                "wd_on_out": ("BOOLEAN", {"default": True}),
            }
        }
    
    RETURN_TYPES = ("MODEL", "CLIP")
    FUNCTION = "load_glokr"
    CATEGORY = "loaders"

    def load_glokr(self, model, clip, lora_name, strength_model, strength_clip, rs_lora, wd_on_out):
        if strength_model == 0.0 and strength_clip == 0.0:
            return (model, clip)

        lora_path = folder_paths.get_full_path("loras", lora_name)
        if lora_path is None:
            raise FileNotFoundError(f"GLoKR LoRA '{lora_name}' not found.")

        lora_sd = comfy.utils.load_torch_file(lora_path)

        key_map_unet = {}
        if model is not None:
            key_map_unet = comfy.lora.model_lora_keys_unet(model.model, key_map_unet)
            
        key_map_clip = {}
        if clip is not None:
            key_map_clip = comfy.lora.model_lora_keys_clip(clip.cond_stage_model, key_map_clip)

        groups = {}
        for key, tensor in lora_sd.items():
            if "." in key:
                base, suffix = key.rsplit(".", 1)
                if base not in groups:
                    groups[base] = {}
                groups[base][suffix] = tensor

        unet_patches = {}
        clip_patches = {}

        def rebuild_tucker(t, a, b):
            return torch.einsum("i j ..., i u, j v -> u v ...", t, a, b)

        def make_kron_local(w1, w2):
            if len(w2.shape) == 4:
                w1 = w1.unsqueeze(2).unsqueeze(2)
                w2 = w2.contiguous()
            return torch.kron(w1, w2)

        def apply_weight_decompose(weight, dora_scale, wd_on_out=True, multiplier=1.0):
            target_dtype = weight.dtype
            weight = weight.to(dora_scale.dtype)
            dora_norm_dims = weight.dim() - 1
            
            if wd_on_out:
                weight_norm = (
                    weight.reshape(weight.shape[0], -1)
                    .norm(dim=1)
                    .reshape(weight.shape[0], *[1] * dora_norm_dims)
                ) + torch.finfo(weight.dtype).eps
            else:
                weight_norm = (
                    weight.transpose(0, 1)
                    .reshape(weight.shape[1], -1)
                    .norm(dim=1, keepdim=True)
                    .reshape(weight.shape[1], *[1] * dora_norm_dims)
                    .transpose(0, 1)
                ) + torch.finfo(weight.dtype).eps

            scale = dora_scale.to(weight.device) / weight_norm
            if multiplier != 1.0:
                scale = multiplier * (scale - 1.0) + 1.0

            return (weight * scale).to(target_dtype)

        for base_key, group in groups.items():
            target_key = None
            is_unet = False
            current_strength = 1.0

            if base_key in key_map_unet:
                target_key = key_map_unet[base_key]
                is_unet = True
                current_strength = strength_model
            elif base_key in key_map_clip:
                target_key = key_map_clip[base_key]
                is_unet = False
                current_strength = strength_clip
            else:
                normalized_base = base_key.replace("lora_unet_", "").replace("lora_te_", "").replace("lora_te1_", "").replace("lora_te2_", "")
                matched = False
                for k_map, v_map in key_map_unet.items():
                    norm_map = k_map.replace("lora_unet_", "")
                    if normalized_base == norm_map:
                        target_key = v_map
                        is_unet = True
                        current_strength = strength_model
                        matched = True
                        break
                if not matched:
                    for k_map, v_map in key_map_clip.items():
                        norm_map = k_map.replace("lora_te_", "").replace("lora_te1_", "").replace("lora_te2_", "")
                        if normalized_base == norm_map:
                            target_key = v_map
                            is_unet = False
                            current_strength = strength_clip
                            matched = True
                            break

            if target_key is None or current_strength == 0.0:
                continue

            if is_unet:
                base_sd = model.model.state_dict()
            else:
                base_sd = clip.cond_stage_model.state_dict()

            if target_key not in base_sd:
                continue

            orig_weight = base_sd[target_key]
            orig_shape = orig_weight.shape
            out_dim = orig_shape[0]
            in_dim = orig_shape[1]

            group_cpu = {k: v.cpu().float() for k, v in group.items()}

            lora_dim = 1
            for k in ["b_w1_a", "b_w2_a", "a_w1_a", "a_w2_a"]:
                if k in group_cpu:
                    lora_dim = group_cpu[k].shape[1]
                    break

            alpha = group_cpu.get("alpha", torch.tensor(lora_dim)).item()
            if alpha == 0:
                alpha = lora_dim

            scalar = group_cpu.get("scalar", torch.tensor(1.0)).item()

            use_b_w1 = "b_w1" in group_cpu
            use_b_w2 = "b_w2" in group_cpu
            use_a_w1 = "a_w1" in group_cpu
            use_a_w2 = "a_w2" in group_cpu

            r_factor = math.sqrt(lora_dim) if rs_lora else lora_dim
            scale_b = 1.0 if (use_b_w2 and use_b_w1) else (alpha / r_factor)
            scale_a = 1.0 if (use_a_w2 and use_a_w1) else (alpha / r_factor)

            b_w1_prod = None
            if "b_w1" in group_cpu:
                b_w1_prod = group_cpu["b_w1"]
            elif "b_w1_a" in group_cpu and "b_w1_b" in group_cpu:
                b_w1_prod = group_cpu["b_w1_a"] @ group_cpu["b_w1_b"]

            b_w2_prod = None
            if "b_w2" in group_cpu:
                b_w2_prod = group_cpu["b_w2"]
            elif "b_w2_a" in group_cpu and "b_w2_b" in group_cpu:
                if "b_t2" in group_cpu:
                    b_w2_prod = rebuild_tucker(group_cpu["b_t2"], group_cpu["b_w2_a"], group_cpu["b_w2_b"])
                else:
                    b_w2_prod = group_cpu["b_w2_a"] @ group_cpu["b_w2_b"]

            if b_w1_prod is not None and b_w2_prod is not None:
                wb = make_kron_local(b_w1_prod, b_w2_prod)
            else:
                wb = b_w1_prod if b_w1_prod is not None else b_w2_prod

            if wb is not None:
                wb = wb.reshape(orig_shape)

            a_w1_prod = None
            if "a_w1" in group_cpu:
                a_w1_prod = group_cpu["a_w1"]
            elif "a_w1_a" in group_cpu and "a_w1_b" in group_cpu:
                a_w1_prod = group_cpu["a_w1_a"] @ group_cpu["a_w1_b"]

            a_w2_prod = None
            if "a_w2" in group_cpu:
                a_w2_prod = group_cpu["a_w2"]
            elif "a_w2_a" in group_cpu and "a_w2_b" in group_cpu:
                a_w2_prod = group_cpu["a_w2_a"] @ group_cpu["a_w2_b"]

            if a_w1_prod is not None and a_w2_prod is not None:
                wa = make_kron_local(a_w1_prod, a_w2_prod)
            else:
                wa = a_w1_prod if a_w1_prod is not None else a_w2_prod

            if wa is not None:
                if len(orig_shape) > 2:
                    wa = wa.reshape(in_dim, in_dim, *(1,) * len(orig_shape[2:]))
                else:
                    wa = wa.reshape(in_dim, in_dim)

            orig_cpu = orig_weight.detach().cpu().float()

            if wa is not None:
                wa_flat = wa.view(wa.size(0), -1)
                if orig_cpu.dim() > 2:
                    w_wa = torch.einsum("o i ..., i j -> o j ...", orig_cpu, wa_flat)
                else:
                    w_wa = orig_cpu @ wa_flat
            else:
                w_wa = torch.zeros_like(orig_cpu)

            scaled_update = torch.zeros_like(orig_cpu)
            if wb is not None:
                scaled_update += wb * scale_b
            if wa is not None:
                scaled_update += w_wa * scale_a

            diff_weight = scaled_update * scalar

            if "dora_scale" in group_cpu:
                dora_scale = group_cpu["dora_scale"]
                new_weight = apply_weight_decompose(
                    orig_cpu + diff_weight * current_strength,
                    dora_scale,
                    wd_on_out,
                    multiplier=current_strength
                )
                patch = new_weight - orig_cpu
            else:
                patch = diff_weight * current_strength

            patch_tensor = patch.to(device=orig_weight.device, dtype=orig_weight.dtype)
            
            if is_unet:
                unet_patches[target_key] = (patch_tensor,)
            else:
                clip_patches[target_key] = (patch_tensor,)

        new_model = model.clone() if model is not None else None
        if new_model is not None and len(unet_patches) > 0:
            new_model.add_patches(unet_patches, strength_patch=1.0)

        new_clip = clip.clone() if clip is not None else None
        if new_clip is not None and len(clip_patches) > 0:
            new_clip.add_patches(clip_patches, strength_patch=1.0)

        return (new_model, new_clip)


NODE_CLASS_MAPPINGS = {
    "GLoKRLoader": GLoKRLoaderNode
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "GLoKRLoader": "GLoKR LoRA Loader"
}