import argparse
import math
import os
import time
from typing import Any, Dict, Union

import torch
from safetensors import safe_open
from safetensors.torch import load_file, save_file
from tqdm import tqdm

from library.utils import setup_logging, str_to_dtype
from library.safetensors_utils import MemoryEfficientSafeOpen, mem_eff_save_file

setup_logging()
import logging

logger = logging.getLogger(__name__)

import lora_flux as lora_flux
from library import sai_model_spec, train_util


def load_state_dict(file_name, dtype):
    if os.path.splitext(file_name)[1] == ".safetensors":
        sd = load_file(file_name)
        metadata = train_util.load_metadata_from_safetensors(file_name)
    else:
        sd = torch.load(file_name, map_location="cpu")
        metadata = {}

    for key in list(sd.keys()):
        if type(sd[key]) == torch.Tensor:
            sd[key] = sd[key].to(dtype)

    return sd, metadata


def save_to_file(file_name, state_dict: Dict[str, Union[Any, torch.Tensor]], dtype, metadata, mem_eff_save=False):
    if dtype is not None:
        logger.info(f"converting to {dtype}...")
        for key in tqdm(list(state_dict.keys())):
            if type(state_dict[key]) == torch.Tensor and state_dict[key].dtype.is_floating_point:
                state_dict[key] = state_dict[key].to(dtype)

    logger.info(f"saving to: {file_name}")
    if mem_eff_save:
        mem_eff_save_file(state_dict, file_name, metadata=metadata)
    else:
        save_file(state_dict, file_name, metadata=metadata)


def merge_to_flux_model(
    loading_device,
    working_device,
    flux_path: str,
    clip_l_path: str,
    t5xxl_path: str,
    models,
    ratios,
    merge_dtype,
    save_dtype,
    mem_eff_load_save=False,
):
    # create module map without loading state_dict
    lora_name_to_module_key = {}
    if flux_path is not None:
        logger.info(f"loading keys from FLUX.1 model: {flux_path}")
        with safe_open(flux_path, framework="pt", device=loading_device) as flux_file:
            keys = list(flux_file.keys())
            for key in keys:
                if key.endswith(".weight"):
                    module_name = ".".join(key.split(".")[:-1])
                    lora_name = lora_flux.LoRANetwork.LORA_PREFIX_FLUX + "_" + module_name.replace(".", "_")
                    lora_name_to_module_key[lora_name] = key

    lora_name_to_clip_l_key = {}
    if clip_l_path is not None:
        logger.info(f"loading keys from clip_l model: {clip_l_path}")
        with safe_open(clip_l_path, framework="pt", device=loading_device) as clip_l_file:
            keys = list(clip_l_file.keys())
            for key in keys:
                if key.endswith(".weight"):
                    module_name = ".".join(key.split(".")[:-1])
                    lora_name = lora_flux.LoRANetwork.LORA_PREFIX_TEXT_ENCODER_CLIP + "_" + module_name.replace(".", "_")
                    lora_name_to_clip_l_key[lora_name] = key

    lora_name_to_t5xxl_key = {}
    if t5xxl_path is not None:
        logger.info(f"loading keys from t5xxl model: {t5xxl_path}")
        with safe_open(t5xxl_path, framework="pt", device=loading_device) as t5xxl_file:
            keys = list(t5xxl_file.keys())
            for key in keys:
                if key.endswith(".weight"):
                    module_name = ".".join(key.split(".")[:-1])
                    lora_name = lora_flux.LoRANetwork.LORA_PREFIX_TEXT_ENCODER_T5 + "_" + module_name.replace(".", "_")
                    lora_name_to_t5xxl_key[lora_name] = key

    flux_state_dict = {}
    clip_l_state_dict = {}
    t5xxl_state_dict = {}
    if mem_eff_load_save:
        if flux_path is not None:
            with MemoryEfficientSafeOpen(flux_path) as flux_file:
                for key in tqdm(flux_file.keys()):
                    flux_state_dict[key] = flux_file.get_tensor(key).to(loading_device)  # dtype is not changed

        if clip_l_path is not None:
            with MemoryEfficientSafeOpen(clip_l_path) as clip_l_file:
                for key in tqdm(clip_l_file.keys()):
                    clip_l_state_dict[key] = clip_l_file.get_tensor(key).to(loading_device)

        if t5xxl_path is not None:
            with MemoryEfficientSafeOpen(t5xxl_path) as t5xxl_file:
                for key in tqdm(t5xxl_file.keys()):
                    t5xxl_state_dict[key] = t5xxl_file.get_tensor(key).to(loading_device)
    else:
        if flux_path is not None:
            flux_state_dict = load_file(flux_path, device=loading_device)
        if clip_l_path is not None:
            clip_l_state_dict = load_file(clip_l_path, device=loading_device)
        if t5xxl_path is not None:
            t5xxl_state_dict = load_file(t5xxl_path, device=loading_device)

    for model, ratio in zip(models, ratios):
        logger.info(f"loading: {model}")
        lora_sd, _ = load_state_dict(model, merge_dtype)  # loading on CPU

        logger.info(f"merging...")
        for key in tqdm(list(lora_sd.keys())):
            if "lora_down" in key:
                lora_name = key[: key.rfind(".lora_down")]
                up_key = key.replace("lora_down", "lora_up")
                alpha_key = key[: key.index("lora_down")] + "alpha"

                if lora_name in lora_name_to_module_key:
                    module_weight_key = lora_name_to_module_key[lora_name]
                    state_dict = flux_state_dict
                elif lora_name in lora_name_to_clip_l_key:
                    module_weight_key = lora_name_to_clip_l_key[lora_name]
                    state_dict = clip_l_state_dict
                elif lora_name in lora_name_to_t5xxl_key:
                    module_weight_key = lora_name_to_t5xxl_key[lora_name]
                    state_dict = t5xxl_state_dict
                else:
                    logger.warning(
                        f"no module found for LoRA weight: {key}. Skipping..."
                        f"LoRAの重みに対応するモジュールが見つかりませんでした。スキップします。"
                    )
                    continue

                down_weight = lora_sd.pop(key)
                up_weight = lora_sd.pop(up_key)

                dim = down_weight.size()[0]
                alpha = lora_sd.pop(alpha_key, dim)
                scale = alpha / dim

                # W <- W + U * D
                weight = state_dict[module_weight_key]

                weight = weight.to(working_device, merge_dtype)
                up_weight = up_weight.to(working_device, merge_dtype)
                down_weight = down_weight.to(working_device, merge_dtype)

                # logger.info(module_name, down_weight.size(), up_weight.size())
                if len(weight.size()) == 2:
                    # linear
                    weight = weight + ratio * (up_weight @ down_weight) * scale
                elif down_weight.size()[2:4] == (1, 1):
                    # conv2d 1x1
                    weight = (
                        weight
                        + ratio
                        * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3)
                        * scale
                    )
                else:
                    # conv2d 3x3
                    conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3)
                    # logger.info(conved.size(), weight.size(), module.stride, module.padding)
                    weight = weight + ratio * conved * scale

                state_dict[module_weight_key] = weight.to(loading_device, save_dtype)
                del up_weight
                del down_weight
                del weight

        if len(lora_sd) > 0:
            logger.warning(f"Unused keys in LoRA model: {list(lora_sd.keys())}")

    return flux_state_dict, clip_l_state_dict, t5xxl_state_dict


def merge_to_flux_model_diffusers(
    loading_device, working_device, flux_model, models, ratios, merge_dtype, save_dtype, mem_eff_load_save=False
):
    logger.info(f"loading keys from FLUX.1 model: {flux_model}")
    if mem_eff_load_save:
        flux_state_dict = {}
        with MemoryEfficientSafeOpen(flux_model) as flux_file:
            for key in tqdm(flux_file.keys()):
                flux_state_dict[key] = flux_file.get_tensor(key).to(loading_device)  # dtype is not changed
    else:
        flux_state_dict = load_file(flux_model, device=loading_device)

    def create_key_map(n_double_layers, n_single_layers):
        key_map = {}
        for index in range(n_double_layers):
            prefix_from = f"transformer_blocks.{index}"
            prefix_to = f"double_blocks.{index}"

            for end in ("weight", "bias"):
                k = f"{prefix_from}.attn."
                qkv_img = f"{prefix_to}.img_attn.qkv.{end}"
                qkv_txt = f"{prefix_to}.txt_attn.qkv.{end}"

                key_map[f"{k}to_q.{end}"] = qkv_img
                key_map[f"{k}to_k.{end}"] = qkv_img
                key_map[f"{k}to_v.{end}"] = qkv_img
                key_map[f"{k}add_q_proj.{end}"] = qkv_txt
                key_map[f"{k}add_k_proj.{end}"] = qkv_txt
                key_map[f"{k}add_v_proj.{end}"] = qkv_txt

            block_map = {
                "attn.to_out.0.weight": "img_attn.proj.weight",
                "attn.to_out.0.bias": "img_attn.proj.bias",
                "norm1.linear.weight": "img_mod.lin.weight",
                "norm1.linear.bias": "img_mod.lin.bias",
                "norm1_context.linear.weight": "txt_mod.lin.weight",
                "norm1_context.linear.bias": "txt_mod.lin.bias",
                "attn.to_add_out.weight": "txt_attn.proj.weight",
                "attn.to_add_out.bias": "txt_attn.proj.bias",
                "ff.net.0.proj.weight": "img_mlp.0.weight",
                "ff.net.0.proj.bias": "img_mlp.0.bias",
                "ff.net.2.weight": "img_mlp.2.weight",
                "ff.net.2.bias": "img_mlp.2.bias",
                "ff_context.net.0.proj.weight": "txt_mlp.0.weight",
                "ff_context.net.0.proj.bias": "txt_mlp.0.bias",
                "ff_context.net.2.weight": "txt_mlp.2.weight",
                "ff_context.net.2.bias": "txt_mlp.2.bias",
                "attn.norm_q.weight": "img_attn.norm.query_norm.scale",
                "attn.norm_k.weight": "img_attn.norm.key_norm.scale",
                "attn.norm_added_q.weight": "txt_attn.norm.query_norm.scale",
                "attn.norm_added_k.weight": "txt_attn.norm.key_norm.scale",
            }

            for k, v in block_map.items():
                key_map[f"{prefix_from}.{k}"] = f"{prefix_to}.{v}"

        for index in range(n_single_layers):
            prefix_from = f"single_transformer_blocks.{index}"
            prefix_to = f"single_blocks.{index}"

            for end in ("weight", "bias"):
                k = f"{prefix_from}.attn."
                qkv = f"{prefix_to}.linear1.{end}"
                key_map[f"{k}to_q.{end}"] = qkv
                key_map[f"{k}to_k.{end}"] = qkv
                key_map[f"{k}to_v.{end}"] = qkv
                key_map[f"{prefix_from}.proj_mlp.{end}"] = qkv

            block_map = {
                "norm.linear.weight": "modulation.lin.weight",
                "norm.linear.bias": "modulation.lin.bias",
                "proj_out.weight": "linear2.weight",
                "proj_out.bias": "linear2.bias",
                "attn.norm_q.weight": "norm.query_norm.scale",
                "attn.norm_k.weight": "norm.key_norm.scale",
            }

            for k, v in block_map.items():
                key_map[f"{prefix_from}.{k}"] = f"{prefix_to}.{v}"

        # add as-is keys
        values = list([(v if isinstance(v, str) else v[0]) for v in set(key_map.values())])
        values.sort()
        key_map.update({v: v for v in values})

        return key_map

    key_map = create_key_map(18, 38)  # 18 double layers, 38 single layers

    def find_matching_key(flux_dict, lora_key):
        lora_key = lora_key.replace("diffusion_model.", "")
        lora_key = lora_key.replace("transformer.", "")
        lora_key = lora_key.replace("lora_A", "lora_down").replace("lora_B", "lora_up")
        lora_key = lora_key.replace("single_transformer_blocks", "single_blocks")
        lora_key = lora_key.replace("transformer_blocks", "double_blocks")

        double_block_map = {
            "attn.to_out.0": "img_attn.proj",
            "norm1.linear": "img_mod.lin",
            "norm1_context.linear": "txt_mod.lin",
            "attn.to_add_out": "txt_attn.proj",
            "ff.net.0.proj": "img_mlp.0",
            "ff.net.2": "img_mlp.2",
            "ff_context.net.0.proj": "txt_mlp.0",
            "ff_context.net.2": "txt_mlp.2",
            "attn.norm_q": "img_attn.norm.query_norm",
            "attn.norm_k": "img_attn.norm.key_norm",
            "attn.norm_added_q": "txt_attn.norm.query_norm",
            "attn.norm_added_k": "txt_attn.norm.key_norm",
            "attn.to_q": "img_attn.qkv",
            "attn.to_k": "img_attn.qkv",
            "attn.to_v": "img_attn.qkv",
            "attn.add_q_proj": "txt_attn.qkv",
            "attn.add_k_proj": "txt_attn.qkv",
            "attn.add_v_proj": "txt_attn.qkv",
        }
        single_block_map = {
            "norm.linear": "modulation.lin",
            "proj_out": "linear2",
            "attn.norm_q": "norm.query_norm",
            "attn.norm_k": "norm.key_norm",
            "attn.to_q": "linear1",
            "attn.to_k": "linear1",
            "attn.to_v": "linear1",
            "proj_mlp": "linear1",
        }

        # same key exists in both single_block_map and double_block_map, so we must care about single/double
        # print("lora_key before double_block_map", lora_key)
        for old, new in double_block_map.items():
            if "double" in lora_key:
                lora_key = lora_key.replace(old, new)
        # print("lora_key before single_block_map", lora_key)
        for old, new in single_block_map.items():
            if "single" in lora_key:
                lora_key = lora_key.replace(old, new)
        # print("lora_key after mapping", lora_key)

        if lora_key in key_map:
            flux_key = key_map[lora_key]
            logger.info(f"Found matching key: {flux_key}")
            return flux_key

        # If not found in key_map, try partial matching
        potential_key = lora_key + ".weight"
        logger.info(f"Searching for key: {potential_key}")
        matches = [k for k in flux_dict.keys() if potential_key in k]
        if matches:
            logger.info(f"Found matching key: {matches[0]}")
            return matches[0]
        return None

    merged_keys = set()
    for model, ratio in zip(models, ratios):
        logger.info(f"loading: {model}")
        lora_sd, _ = load_state_dict(model, merge_dtype)

        logger.info("merging...")
        for key in lora_sd.keys():
            if "lora_down" in key or "lora_A" in key:
                lora_name = key[: key.rfind(".lora_down" if "lora_down" in key else ".lora_A")]
                up_key = key.replace("lora_down", "lora_up").replace("lora_A", "lora_B")
                alpha_key = key[: key.index("lora_down" if "lora_down" in key else "lora_A")] + "alpha"

                logger.info(f"Processing LoRA key: {lora_name}")
                flux_key = find_matching_key(flux_state_dict, lora_name)

                if flux_key is None:
                    logger.warning(f"no module found for LoRA weight: {key}")
                    continue

                logger.info(f"Merging LoRA key {lora_name} into Flux key {flux_key}")

                down_weight = lora_sd[key]
                up_weight = lora_sd[up_key]

                dim = down_weight.size()[0]
                alpha = lora_sd.get(alpha_key, dim)
                scale = alpha / dim

                weight = flux_state_dict[flux_key]

                weight = weight.to(working_device, merge_dtype)
                up_weight = up_weight.to(working_device, merge_dtype)
                down_weight = down_weight.to(working_device, merge_dtype)

                # print(up_weight.size(), down_weight.size(), weight.size())

                if lora_name.startswith("transformer."):
                    if "qkv" in flux_key or "linear1" in flux_key:  # combined qkv or qkv+mlp
                        update = ratio * (up_weight @ down_weight) * scale
                        # print(update.shape)

                        if "img_attn" in flux_key or "txt_attn" in flux_key:
                            q, k, v = torch.chunk(weight, 3, dim=0)
                            if "to_q" in lora_name or "add_q_proj" in lora_name:
                                q += update.reshape(q.shape)
                            elif "to_k" in lora_name or "add_k_proj" in lora_name:
                                k += update.reshape(k.shape)
                            elif "to_v" in lora_name or "add_v_proj" in lora_name:
                                v += update.reshape(v.shape)
                            weight = torch.cat([q, k, v], dim=0)
                        elif "linear1" in flux_key:
                            q, k, v = torch.chunk(weight[: int(update.shape[-1] * 3)], 3, dim=0)
                            mlp = weight[int(update.shape[-1] * 3) :]
                            # print(q.shape, k.shape, v.shape, mlp.shape)
                            if "to_q" in lora_name:
                                q += update.reshape(q.shape)
                            elif "to_k" in lora_name:
                                k += update.reshape(k.shape)
                            elif "to_v" in lora_name:
                                v += update.reshape(v.shape)
                            elif "proj_mlp" in lora_name:
                                mlp += update.reshape(mlp.shape)
                            weight = torch.cat([q, k, v, mlp], dim=0)
                    else:
                        if len(weight.size()) == 2:
                            weight = weight + ratio * (up_weight @ down_weight) * scale
                        elif down_weight.size()[2:4] == (1, 1):
                            weight = (
                                weight
                                + ratio
                                * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3)
                                * scale
                            )
                        else:
                            conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3)
                            weight = weight + ratio * conved * scale
                else:
                    if len(weight.size()) == 2:
                        weight = weight + ratio * (up_weight @ down_weight) * scale
                    elif down_weight.size()[2:4] == (1, 1):
                        weight = (
                            weight
                            + ratio
                            * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3)
                            * scale
                        )
                    else:
                        conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3)
                        weight = weight + ratio * conved * scale

                flux_state_dict[flux_key] = weight.to(loading_device, save_dtype)
                merged_keys.add(flux_key)
                del up_weight
                del down_weight
                del weight

    logger.info(f"Merged keys: {sorted(list(merged_keys))}")
    return flux_state_dict


def merge_lora_models(models, ratios, merge_dtype, concat=False, shuffle=False):
    base_alphas = {}  # alpha for merged model
    base_dims = {}

    merged_sd = {}
    base_model = None
    for model, ratio in zip(models, ratios):
        logger.info(f"loading: {model}")
        lora_sd, lora_metadata = load_state_dict(model, merge_dtype)

        if lora_metadata is not None:
            if base_model is None:
                base_model = lora_metadata.get(train_util.SS_METADATA_KEY_BASE_MODEL_VERSION, None)

        # get alpha and dim
        alphas = {}  # alpha for current model
        dims = {}  # dims for current model
        for key in lora_sd.keys():
            if "alpha" in key:
                lora_module_name = key[: key.rfind(".alpha")]
                alpha = float(lora_sd[key].detach().numpy())
                alphas[lora_module_name] = alpha
                if lora_module_name not in base_alphas:
                    base_alphas[lora_module_name] = alpha
            elif "lora_down" in key:
                lora_module_name = key[: key.rfind(".lora_down")]
                dim = lora_sd[key].size()[0]
                dims[lora_module_name] = dim
                if lora_module_name not in base_dims:
                    base_dims[lora_module_name] = dim

        for lora_module_name in dims.keys():
            if lora_module_name not in alphas:
                alpha = dims[lora_module_name]
                alphas[lora_module_name] = alpha
                if lora_module_name not in base_alphas:
                    base_alphas[lora_module_name] = alpha

        logger.info(f"dim: {list(set(dims.values()))}, alpha: {list(set(alphas.values()))}")

        # merge
        logger.info("merging...")
        for key in tqdm(lora_sd.keys()):
            if "alpha" in key:
                continue

            if "lora_up" in key and concat:
                concat_dim = 1
            elif "lora_down" in key and concat:
                concat_dim = 0
            else:
                concat_dim = None

            lora_module_name = key[: key.rfind(".lora_")]

            base_alpha = base_alphas[lora_module_name]
            alpha = alphas[lora_module_name]

            scale = math.sqrt(alpha / base_alpha) * ratio
            scale = abs(scale) if "lora_up" in key else scale  # マイナスの重みに対応する。

            if key in merged_sd:
                assert (
                    merged_sd[key].size() == lora_sd[key].size() or concat_dim is not None
                ), "weights shape mismatch, different dims? / 重みのサイズが合いません。dimが異なる可能性があります。"
                if concat_dim is not None:
                    merged_sd[key] = torch.cat([merged_sd[key], lora_sd[key] * scale], dim=concat_dim)
                else:
                    merged_sd[key] = merged_sd[key] + lora_sd[key] * scale
            else:
                merged_sd[key] = lora_sd[key] * scale

    # set alpha to sd
    for lora_module_name, alpha in base_alphas.items():
        key = lora_module_name + ".alpha"
        merged_sd[key] = torch.tensor(alpha)
        if shuffle:
            key_down = lora_module_name + ".lora_down.weight"
            key_up = lora_module_name + ".lora_up.weight"
            dim = merged_sd[key_down].shape[0]
            perm = torch.randperm(dim)
            merged_sd[key_down] = merged_sd[key_down][perm]
            merged_sd[key_up] = merged_sd[key_up][:, perm]

    logger.info("merged model")
    logger.info(f"dim: {list(set(base_dims.values()))}, alpha: {list(set(base_alphas.values()))}")

    # check all dims are same
    dims_list = list(set(base_dims.values()))
    alphas_list = list(set(base_alphas.values()))
    all_same_dims = True
    all_same_alphas = True
    for dims in dims_list:
        if dims != dims_list[0]:
            all_same_dims = False
            break
    for alphas in alphas_list:
        if alphas != alphas_list[0]:
            all_same_alphas = False
            break

    # build minimum metadata
    dims = f"{dims_list[0]}" if all_same_dims else "Dynamic"
    alphas = f"{alphas_list[0]}" if all_same_alphas else "Dynamic"
    metadata = train_util.build_minimum_network_metadata(str(False), base_model, "networks.lora", dims, alphas, None)

    return merged_sd, metadata


def merge(args):
    if args.models is None:
        args.models = []
    if args.ratios is None:
        args.ratios = []

    assert len(args.models) == len(
        args.ratios
    ), "number of models must be equal to number of ratios / モデルの数と重みの数は合わせてください"

    merge_dtype = str_to_dtype(args.precision)
    save_dtype = str_to_dtype(args.save_precision)
    if save_dtype is None:
        save_dtype = merge_dtype

    assert (
        args.save_to or args.clip_l_save_to or args.t5xxl_save_to
    ), "save_to or clip_l_save_to or t5xxl_save_to must be specified / save_toまたはclip_l_save_toまたはt5xxl_save_toを指定してください"
    dest_dir = os.path.dirname(args.save_to or args.clip_l_save_to or args.t5xxl_save_to)
    if not os.path.exists(dest_dir):
        logger.info(f"creating directory: {dest_dir}")
        os.makedirs(dest_dir)

    if args.flux_model is not None or args.clip_l is not None or args.t5xxl is not None:
        if not args.diffusers:
            assert (args.clip_l is None and args.clip_l_save_to is None) or (
                args.clip_l is not None and args.clip_l_save_to is not None
            ), "clip_l_save_to must be specified if clip_l is specified / clip_lが指定されている場合はclip_l_save_toも指定してください"
            assert (args.t5xxl is None and args.t5xxl_save_to is None) or (
                args.t5xxl is not None and args.t5xxl_save_to is not None
            ), "t5xxl_save_to must be specified if t5xxl is specified / t5xxlが指定されている場合はt5xxl_save_toも指定してください"
            flux_state_dict, clip_l_state_dict, t5xxl_state_dict = merge_to_flux_model(
                args.loading_device,
                args.working_device,
                args.flux_model,
                args.clip_l,
                args.t5xxl,
                args.models,
                args.ratios,
                merge_dtype,
                save_dtype,
                args.mem_eff_load_save,
            )
        else:
            assert (
                args.clip_l is None and args.t5xxl is None
            ), "clip_l and t5xxl are not supported with --diffusers / clip_l、t5xxlはDiffusersではサポートされていません"
            flux_state_dict = merge_to_flux_model_diffusers(
                args.loading_device,
                args.working_device,
                args.flux_model,
                args.models,
                args.ratios,
                merge_dtype,
                save_dtype,
                args.mem_eff_load_save,
            )
            clip_l_state_dict = None
            t5xxl_state_dict = None

        if args.no_metadata or (flux_state_dict is None or len(flux_state_dict) == 0):
            sai_metadata = None
        else:
            merged_from = sai_model_spec.build_merged_from([args.flux_model] + args.models)
            title = os.path.splitext(os.path.basename(args.save_to))[0]
            sai_metadata = sai_model_spec.build_metadata(
                None,
                False,
                False,
                False,
                False,
                False,
                time.time(),
                title=title,
                merged_from=merged_from,
                model_config={"flux": "dev"},
            )

        if flux_state_dict is not None and len(flux_state_dict) > 0:
            logger.info(f"saving FLUX model to: {args.save_to}")
            save_to_file(args.save_to, flux_state_dict, save_dtype, sai_metadata, args.mem_eff_load_save)

        if clip_l_state_dict is not None and len(clip_l_state_dict) > 0:
            logger.info(f"saving clip_l model to: {args.clip_l_save_to}")
            save_to_file(args.clip_l_save_to, clip_l_state_dict, save_dtype, None, args.mem_eff_load_save)

        if t5xxl_state_dict is not None and len(t5xxl_state_dict) > 0:
            logger.info(f"saving t5xxl model to: {args.t5xxl_save_to}")
            save_to_file(args.t5xxl_save_to, t5xxl_state_dict, save_dtype, None, args.mem_eff_load_save)

    else:
        flux_state_dict, metadata = merge_lora_models(args.models, args.ratios, merge_dtype, args.concat, args.shuffle)

        logger.info("calculating hashes and creating metadata...")

        model_hash, legacy_hash = train_util.precalculate_safetensors_hashes(flux_state_dict, metadata)
        metadata["sshs_model_hash"] = model_hash
        metadata["sshs_legacy_hash"] = legacy_hash

        if not args.no_metadata:
            merged_from = sai_model_spec.build_merged_from(args.models)
            title = os.path.splitext(os.path.basename(args.save_to))[0]
            sai_metadata = sai_model_spec.build_metadata(
                flux_state_dict,
                False,
                False,
                False,
                True,
                False,
                time.time(),
                title=title,
                merged_from=merged_from,
                model_config={"flux": "dev"},
            )
            metadata.update(sai_metadata)

        logger.info(f"saving model to: {args.save_to}")
        save_to_file(args.save_to, flux_state_dict, save_dtype, metadata)


def setup_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--save_precision",
        type=str,
        default=None,
        help="precision in saving, same to merging if omitted. supported types: "
        "float32, fp16, bf16, fp8 (same as fp8_e4m3fn), fp8_e4m3fn, fp8_e4m3fnuz, fp8_e5m2, fp8_e5m2fnuz"
        " / 保存時に精度を変更して保存する、省略時はマージ時の精度と同じ",
    )
    parser.add_argument(
        "--precision",
        type=str,
        default="float",
        help="precision in merging (float is recommended) / マージの計算時の精度（floatを推奨）",
    )
    parser.add_argument(
        "--flux_model",
        type=str,
        default=None,
        help="FLUX.1 model to load, merge LoRA models if omitted / 読み込むモデル、指定しない場合はLoRAモデルをマージする",
    )
    parser.add_argument(
        "--clip_l",
        type=str,
        default=None,
        help="path to clip_l (*.sft or *.safetensors), should be float16 / clip_lのパス（*.sftまたは*.safetensors）",
    )
    parser.add_argument(
        "--t5xxl",
        type=str,
        default=None,
        help="path to t5xxl (*.sft or *.safetensors), should be float16 / t5xxlのパス（*.sftまたは*.safetensors）",
    )
    parser.add_argument(
        "--mem_eff_load_save",
        action="store_true",
        help="use custom memory efficient load and save functions for FLUX.1 model"
        " / カスタムのメモリ効率の良い読み込みと保存関数をFLUX.1モデルに使用する",
    )
    parser.add_argument(
        "--loading_device",
        type=str,
        default="cpu",
        help="device to load FLUX.1 model. LoRA models are loaded on CPU / FLUX.1モデルを読み込むデバイス。LoRAモデルはCPUで読み込まれます",
    )
    parser.add_argument(
        "--working_device",
        type=str,
        default="cpu",
        help="device to work (merge). Merging LoRA models are done on CPU."
        + " / 作業（マージ）するデバイス。LoRAモデルのマージはCPUで行われます。",
    )
    parser.add_argument(
        "--save_to",
        type=str,
        default=None,
        help="destination file name: safetensors file / 保存先のファイル名、safetensorsファイル",
    )
    parser.add_argument(
        "--clip_l_save_to",
        type=str,
        default=None,
        help="destination file name for clip_l: safetensors file / clip_lの保存先のファイル名、safetensorsファイル",
    )
    parser.add_argument(
        "--t5xxl_save_to",
        type=str,
        default=None,
        help="destination file name for t5xxl: safetensors file / t5xxlの保存先のファイル名、safetensorsファイル",
    )
    parser.add_argument(
        "--models",
        type=str,
        nargs="*",
        help="LoRA models to merge: safetensors file / マージするLoRAモデル、safetensorsファイル",
    )
    parser.add_argument("--ratios", type=float, nargs="*", help="ratios for each model / それぞれのLoRAモデルの比率")
    parser.add_argument(
        "--no_metadata",
        action="store_true",
        help="do not save sai modelspec metadata (minimum ss_metadata for LoRA is saved) / "
        + "sai modelspecのメタデータを保存しない（LoRAの最低限のss_metadataは保存される）",
    )
    parser.add_argument(
        "--concat",
        action="store_true",
        help="concat lora instead of merge (The dim(rank) of the output LoRA is the sum of the input dims) / "
        + "マージの代わりに結合する（LoRAのdim(rank)は入力dimの合計になる）",
    )
    parser.add_argument(
        "--shuffle",
        action="store_true",
        help="shuffle lora weight./ " + "LoRAの重みをシャッフルする",
    )
    parser.add_argument(
        "--diffusers",
        action="store_true",
        help="merge Diffusers (?) LoRA models / Diffusers (?) LoRAモデルをマージする",
    )

    return parser


if __name__ == "__main__":
    parser = setup_parser()

    args = parser.parse_args()
    merge(args)
