"""
StarGAN v2
Copyright (c) 2020-present NAVER Corp.

This work is licensed under the Creative Commons Attribution-NonCommercial
4.0 International License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to
Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
"""

import os
from os.path import join as ospj
import time
import datetime
from munch import Munch

import torch
import torch.nn as nn
import torch.nn.functional as F

from core.model import build_model
from core.checkpoint import CheckpointIO
from core.data_loader import InputFetcher
import core.utils as utils
from metrics.eval import calculate_metrics


class Solver(nn.Module):
    def __init__(self, args):
        super().__init__()
        self.args = args
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

        self.nets, self.nets_ema, self.vgg, self.VggExtract = build_model(args)
        self.instancenorm = nn.InstanceNorm2d(512, affine=False)
        self.L1Loss = nn.L1Loss()
        # below setattrs are to make networks be children of Solver, e.g., for self.to(self.device)
        for name, module in self.nets.items():
            utils.print_network(module, name)
            setattr(self, name, module)
        for name, module in self.nets_ema.items():
            setattr(self, name + '_ema', module)

        if args.mode == 'train':
            self.optims = Munch()
            for net in self.nets.keys():
                if net == 'fan':
                    continue
                self.optims[net] = torch.optim.Adam(
                    params=self.nets[net].parameters(),
                    lr=args.f_lr if net == 'mapping_network' else args.lr,
                    betas=[args.beta1, args.beta2],
                    weight_decay=args.weight_decay)

            self.ckptios = [CheckpointIO(ospj(args.checkpoint_dir, '100000_nets.ckpt'), **self.nets),
                CheckpointIO(ospj(args.checkpoint_dir, '100000_nets_ema.ckpt'), **self.nets_ema),
                CheckpointIO(ospj(args.checkpoint_dir, '100000_optims.ckpt'), **self.optims)]
        else:
            self.ckptios = [CheckpointIO(ospj(args.checkpoint_dir, '100000_nets_ema.ckpt'), **self.nets_ema)]

        self.to(self.device)
        for name, network in self.named_children():
            # Do not initialize the FAN parameters
            if ('ema' not in name) and ('fan' not in name):
                print('Initializing %s...' % name)
                network.apply(utils.he_init)

    def _save_checkpoint(self, step):
        for ckptio in self.ckptios:
            ckptio.save(step)

    def _load_checkpoint(self, step):
        for ckptio in self.ckptios:
            ckptio.load(step)

    def _reset_grad(self):
        for optim in self.optims.values():
            optim.zero_grad()

    def train(self, loaders):
        args = self.args
        nets = self.nets
        nets_ema = self.nets_ema
        optims = self.optims

        # fetch random validation images for debugging
        fetcher = InputFetcher(loaders.src, loaders.ref, args.latent_dim, 'train')
        fetcher_val = InputFetcher(loaders.val, None, args.latent_dim, 'val')
        inputs_val = next(fetcher_val)

        # resume training if necessary
        if args.resume_iter > 0:
            self._load_checkpoint(args.resume_iter)

        # remember the initial value of ds weight
        initial_lambda_ds = args.lambda_ds

        print('Start training...')
        start_time = time.time()
        for i in range(args.resume_iter, args.total_iters):
            # fetch images and labels
            inputs = next(fetcher)
            x_real, y_org = inputs.x_src, inputs.y_src
            x_ref, x_ref2, y_trg = inputs.x_ref, inputs.x_ref2, inputs.y_ref
            z_trg, z_trg2 = inputs.z_trg, inputs.z_trg2

            masks = nets.fan.get_heatmap(x_real) if args.w_hpf > 0 else None

            # train the discriminator
            d_loss, d_losses_latent = compute_d_loss(
                nets, args, x_real, y_org, y_trg, z_trg=z_trg, masks=masks)
            self._reset_grad()
            d_loss.backward()
            optims.discriminator.step()

            d_loss, d_losses_ref = compute_d_loss(
                nets, args, x_real, y_org, y_trg, x_ref=x_ref, masks=masks)
            self._reset_grad()
            d_loss.backward()
            optims.discriminator.step()

            # train the generator
            g_loss, g_losses_latent = compute_g_loss(
                nets, args, x_real, y_org, y_trg, z_trgs=[z_trg, z_trg2], masks=masks,VggExtract=self.VggExtract, IN = self.instancenorm, L1Loss=self.L1Loss)
            self._reset_grad()
            g_loss.backward()
            optims.generator.step()
            optims.mapping_network.step()
            optims.style_encoder.step()

            g_loss, g_losses_ref = compute_g_loss(
                nets, args, x_real, y_org, y_trg, x_refs=[x_ref, x_ref2], masks=masks, VggExtract=self.VggExtract, IN = self.instancenorm, L1Loss=self.L1Loss)
            self._reset_grad()
            g_loss.backward()
            optims.generator.step()

            # compute moving average of network parameters
            moving_average(nets.generator, nets_ema.generator, beta=0.999)
            moving_average(nets.mapping_network, nets_ema.mapping_network, beta=0.999)
            moving_average(nets.style_encoder, nets_ema.style_encoder, beta=0.999)

            # decay weight for diversity sensitive loss
            if args.lambda_ds > 0:
                args.lambda_ds -= (initial_lambda_ds / args.ds_iter)

            # print out log info
            if (i+1) % args.print_every == 0:
                elapsed = time.time() - start_time
                elapsed = str(datetime.timedelta(seconds=elapsed))[:-7]
                log = "Elapsed time [%s], Iteration [%i/%i], " % (elapsed, i+1, args.total_iters)
                all_losses = dict()
                for loss, prefix in zip([d_losses_latent, d_losses_ref, g_losses_latent, g_losses_ref],
                                        ['D/latent_', 'D/ref_', 'G/latent_', 'G/ref_']):
                    for key, value in loss.items():
                        all_losses[prefix + key] = value
                all_losses['G/lambda_ds'] = args.lambda_ds
                log += ' '.join(['%s: [%.4f]' % (key, value) for key, value in all_losses.items()])
                print(log)

            # generate images for debugging
            if (i+1) % args.sample_every == 0:
                os.makedirs(args.sample_dir, exist_ok=True)
                utils.debug_image(nets_ema, args, inputs=inputs_val, step=i+1)

            # save model checkpoints
            if (i+1) % args.save_every == 0:
                self._save_checkpoint(step=i+1)

            # compute FID and LPIPS if necessary
            if (i+1) % args.eval_every == 0:
                calculate_metrics(nets_ema, args, i+1, mode='latent')
                calculate_metrics(nets_ema, args, i+1, mode='reference')

    @torch.no_grad()
    def sample(self, loaders):
        args = self.args
        nets_ema = self.nets_ema
        os.makedirs(args.result_dir, exist_ok=True)
        self._load_checkpoint(args.resume_iter)

        src = next(InputFetcher(loaders.src, None, args.latent_dim, 'test'))
        ref = next(InputFetcher(loaders.ref, None, args.latent_dim, 'test'))

        fname = ospj(args.result_dir, 'reference.jpg')
        print('Working on {}...'.format(fname))
        utils.translate_using_reference(nets_ema, args, src.x, ref.x, ref.y, fname)

        # fname = ospj(args.result_dir, 'video_ref.mp4')
        # print('Working on {}...'.format(fname))
        # utils.video_ref(nets_ema, args, src.x, ref.x, ref.y, fname)

    @torch.no_grad()
    def evaluate(self):
        args = self.args
        nets_ema = self.nets_ema
        resume_iter = args.resume_iter
        self._load_checkpoint(args.resume_iter)
        calculate_metrics(nets_ema, args, step=resume_iter, mode='latent')
        calculate_metrics(nets_ema, args, step=resume_iter, mode='reference')


def compute_d_loss(nets, args, x_real, y_org, y_trg, z_trg=None, x_ref=None, masks=None):
    assert (z_trg is None) != (x_ref is None)
    # with real images
    x_real.requires_grad_()
    out = nets.discriminator(x_real, y_org)
    loss_real = adv_loss(out, 1)
    loss_reg = r1_reg(out, x_real)

    # with fake images
    with torch.no_grad():
        if z_trg is not None:
            s_trg = nets.mapping_network(z_trg, y_trg)
        else:  # x_ref is not None
            s_trg = nets.style_encoder(x_ref, y_trg)

        x_fake,_ = nets.generator(x_real, s_trg, masks=masks)
    out = nets.discriminator(x_fake, y_trg)
    loss_fake = adv_loss(out, 0)

    loss = loss_real + loss_fake + args.lambda_reg * loss_reg
    return loss, Munch(real=loss_real.item(),
                       fake=loss_fake.item(),
                       reg=loss_reg.item())


def compute_g_loss(nets, args, x_real, y_org, y_trg, z_trgs=None, x_refs=None, masks=None,  VggExtract= None, IN= None, L1Loss=None):
    assert (z_trgs is None) != (x_refs is None)
    if z_trgs is not None:
        z_trg, z_trg2 = z_trgs
    if x_refs is not None:
        x_ref, x_ref2 = x_refs

    # adversarial loss
    if z_trgs is not None:
        s_trg = nets.mapping_network(z_trg, y_trg)
    else:
        s_trg = nets.style_encoder(x_ref, y_trg)

    x_fake, content_latent_real = nets.generator(x_real, s_trg, masks=masks)
    out = nets.discriminator(x_fake, y_trg)
    loss_adv = adv_loss(out, 1)

    # style reconstruction loss
    s_pred = nets.style_encoder(x_fake, y_trg)
    loss_sty = torch.mean(torch.abs(s_pred - s_trg))

    # diversity sensitive loss
    if z_trgs is not None:
        s_trg2 = nets.mapping_network(z_trg2, y_trg)
    else:
        s_trg2 = nets.style_encoder(x_ref2, y_trg)
    x_fake2, content_latent_real2 = nets.generator(x_real, s_trg2, masks=masks)
    x_fake2 = x_fake2.detach()
    loss_ds = torch.mean(torch.abs(x_fake - x_fake2))

    # cycle-consistency loss
    masks = nets.fan.get_heatmap(x_fake) if args.w_hpf > 0 else None
    s_org = nets.style_encoder(x_real, y_org)
    x_rec, content_latent_reco = nets.generator(x_fake, s_org, masks=masks)
    loss_cyc = torch.mean(torch.abs(x_rec - x_real))

    loss_vgg = compute_vgg_loss(x_fake, x_real, VggExtract, IN, L1Loss) if args.vgg_w > 0 else 0
    loss_sacl = utils.abs_criterion(content_latent_real,  content_latent_reco) if args.loss_sacl > 0 else 0 # Loss style aware content loss
    loss_sacl2 = utils.abs_criterion(content_latent_real2,  content_latent_reco) if args.loss_sacl > 0 else 0 # Loss style aware content loss

    loss = loss_adv + args.lambda_sty * loss_sty \
        - args.lambda_ds * loss_ds + args.lambda_cyc * loss_cyc + args.lambda_vgg * loss_vgg + args.lambda_loss_sacl * loss_sacl+ args.lambda_loss_sacl * loss_sacl2
    return loss, Munch(adv=loss_adv.item(),
                       sty=loss_sty.item(),
                       ds=loss_ds.item(),
                       cyc=loss_cyc.item())


def moving_average(model, model_test, beta=0.999):
    for param, param_test in zip(model.parameters(), model_test.parameters()):
        param_test.data = torch.lerp(param.data, param_test.data, beta)


def adv_loss(logits, target):
    assert target in [1, 0]
    targets = torch.full_like(logits, fill_value=target)
    loss = F.binary_cross_entropy_with_logits(logits, targets)
    return loss

def compute_vgg_loss(img, target, VggExtract, IN, L1Loss):
    # img_vgg = utils.vgg_preprocess(img)
    # target_vgg =  utils.vgg_preprocess(target)
    # img_fea = vgg(img_vgg)
    # target_fea = vgg(target_vgg)
    img_fea_dict = VggExtract(img)
    target_fea_dict = VggExtract(target)
    # loss = torch.mean((img_fea_dict['relu3_3'] - target_fea_dict['relu3_3']) ** 2)
    # loss = torch.mean(torch.abs(img_fea_dict['relu3_3'] - target_fea_dict['relu3_3']))
    loss = L1Loss(img_fea_dict['relu2_2'] , target_fea_dict['relu2_2'])
    return loss

def r1_reg(d_out, x_in):
    # zero-centered gradient penalty for real images
    batch_size = x_in.size(0)
    grad_dout = torch.autograd.grad(
        outputs=d_out.sum(), inputs=x_in,
        create_graph=True, retain_graph=True, only_inputs=True
    )[0]
    grad_dout2 = grad_dout.pow(2)
    assert(grad_dout2.size() == x_in.size())
    reg = 0.5 * grad_dout2.view(batch_size, -1).sum(1).mean(0)
    return reg
[(174, 'torch.no_grad', 'torch.no_grad', False, 'import torch\n'), (192, 'torch.no_grad', 'torch.no_grad', False, 'import torch\n'), (282, 'torch.full_like', 'torch.full_like', False, 'import torch\n'), (283, 'torch.nn.functional.binary_cross_entropy_with_logits', 'F.binary_cross_entropy_with_logits', True, 'import torch.nn.functional as F\n'), (34, 'core.model.build_model', 'build_model', False, 'from core.model import build_model\n'), (35, 'torch.nn.InstanceNorm2d', 'nn.InstanceNorm2d', True, 'import torch.nn as nn\n'), (36, 'torch.nn.L1Loss', 'nn.L1Loss', True, 'import torch.nn as nn\n'), (87, 'core.data_loader.InputFetcher', 'InputFetcher', False, 'from core.data_loader import InputFetcher\n'), (88, 'core.data_loader.InputFetcher', 'InputFetcher', False, 'from core.data_loader import InputFetcher\n'), (99, 'time.time', 'time.time', False, 'import time\n'), (178, 'os.makedirs', 'os.makedirs', False, 'import os\n'), (184, 'os.path.join', 'ospj', True, 'from os.path import join as ospj\n'), (186, 'core.utils.translate_using_reference', 'utils.translate_using_reference', True, 'import core.utils as utils\n'), (198, 'metrics.eval.calculate_metrics', 'calculate_metrics', False, 'from metrics.eval import calculate_metrics\n'), (199, 'metrics.eval.calculate_metrics', 'calculate_metrics', False, 'from metrics.eval import calculate_metrics\n'), (211, 'torch.no_grad', 'torch.no_grad', False, 'import torch\n'), (246, 'torch.abs', 'torch.abs', False, 'import torch\n'), (255, 'torch.abs', 'torch.abs', False, 'import torch\n'), (261, 'torch.abs', 'torch.abs', False, 'import torch\n'), (264, 'core.utils.abs_criterion', 'utils.abs_criterion', True, 'import core.utils as utils\n'), (265, 'core.utils.abs_criterion', 'utils.abs_criterion', True, 'import core.utils as utils\n'), (277, 'torch.lerp', 'torch.lerp', False, 'import torch\n'), (39, 'core.utils.print_network', 'utils.print_network', True, 'import core.utils as utils\n'), (45, 'munch.Munch', 'Munch', False, 'from munch import Munch\n'), (181, 'core.data_loader.InputFetcher', 'InputFetcher', False, 'from core.data_loader import InputFetcher\n'), (182, 'core.data_loader.InputFetcher', 'InputFetcher', False, 'from core.data_loader import InputFetcher\n'), (32, 'torch.cuda.is_available', 'torch.cuda.is_available', False, 'import torch\n'), (162, 'os.makedirs', 'os.makedirs', False, 'import os\n'), (163, 'core.utils.debug_image', 'utils.debug_image', True, 'import core.utils as utils\n'), (171, 'metrics.eval.calculate_metrics', 'calculate_metrics', False, 'from metrics.eval import calculate_metrics\n'), (172, 'metrics.eval.calculate_metrics', 'calculate_metrics', False, 'from metrics.eval import calculate_metrics\n'), (55, 'os.path.join', 'ospj', True, 'from os.path import join as ospj\n'), (56, 'os.path.join', 'ospj', True, 'from os.path import join as ospj\n'), (57, 'os.path.join', 'ospj', True, 'from os.path import join as ospj\n'), (59, 'os.path.join', 'ospj', True, 'from os.path import join as ospj\n'), (148, 'time.time', 'time.time', False, 'import time\n'), (149, 'datetime.timedelta', 'datetime.timedelta', False, 'import datetime\n')]