"""This module contains simple helper functions """
from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import os
import torchvision
import sys
import shutil
import datetime


def check_path_is_static_data(path):
    last_extension = path.split(".")[-1]
    acceptable_extensions = ['png', 'jpg', 'jpeg', 'npy', 'npz']
    if last_extension.lower() in acceptable_extensions:
        return True
    return False

def check_path(path):
    try:
        if not os.path.exists(path):
            os.makedirs(path)
    except OSError as e:
        print(e)


def tensor2file(input_image, file_path, ext_name):
    """Convert a tensor into a file.

    Parameters:
        input_image  --  the input image tensor
        file_path    --  the file path without extension name
    """
    if not isinstance(input_image, np.ndarray):
        if isinstance(input_image, torch.Tensor):  # get the data from a variable
            image_tensor = input_image.data
        else:
            return input_image
        image_numpy = image_tensor[0].cpu().float().numpy()  # convert it into a numpy array
        if image_numpy.shape[0] == 1:  # grayscale to RGB
            image_numpy = np.tile(image_numpy, (3, 1, 1))
        image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0  # post-processing: tranpose and scaling
    else:  # if it is a numpy array, do nothing
        image_numpy = input_image

    if image_numpy.shape[2] <= 3:
        image_numpy = image_numpy.astype(np.uint8)
        # save as image
        image_pil = Image.fromarray(image_numpy)
        image_pil.save(file_path + '.' + ext_name)
    else:
        # save as numpy
        np.save(file_path + '.npy', image_numpy)


def tensor2im(input_image, imtype=np.uint8):
    """"Converts a Tensor array into a numpy image array.

    Parameters:
        input_image (tensor) --  the input image tensor array
        imtype (type)        --  the desired type of the converted numpy array
    """
    if not isinstance(input_image, np.ndarray):
        if isinstance(input_image, torch.Tensor):  # get the data from a variable
            image_tensor = input_image.data
        else:
            return input_image
        image_numpy = image_tensor[0].cpu().float().numpy()  # convert it into a numpy array
        if image_numpy.shape[0] == 1:  # grayscale to RGB
            image_numpy = np.tile(image_numpy, (3, 1, 1))
        image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0  # post-processing: tranpose and scaling
        if image_numpy.shape[2] > 3: # clip to 3 channel
            print('Warning: the channel count of output image exceeds 3.')
            image_numpy = image_numpy[:,:,:3]
    else:  # if it is a numpy array, do nothing
        image_numpy = input_image
    return image_numpy.astype(imtype)


def diagnose_network(net, name='network'):
    """Calculate and print the mean of average absolute(gradients)

    Parameters:
        net (torch network) -- Torch network
        name (str) -- the name of the network
    """
    mean = 0.0
    count = 0
    for param in net.parameters():
        if param.grad is not None:
            mean += torch.mean(torch.abs(param.grad.data))
            count += 1
    if count > 0:
        mean = mean / count
    print(name)
    print(mean)


def save_image(image_numpy, image_path, aspect_ratio=1.0):
    """Save a numpy image to the disk

    Parameters:
        image_numpy (numpy array) -- input numpy array
        image_path (str)          -- the path of the image
    """

    image_pil = Image.fromarray(image_numpy)
    h, w, _ = image_numpy.shape

    if aspect_ratio > 1.0:
        image_pil = image_pil.resize((h, int(w * aspect_ratio)), Image.BICUBIC)
    if aspect_ratio < 1.0:
        image_pil = image_pil.resize((int(h / aspect_ratio), w), Image.BICUBIC)
    image_pil.save(image_path)


def print_numpy(x, val=True, shp=False):
    """Print the mean, min, max, median, std, and size of a numpy array

    Parameters:
        val (bool) -- if print the values of the numpy array
        shp (bool) -- if print the shape of the numpy array
    """
    x = x.astype(np.float64)
    if shp:
        print('shape,', x.shape)
    if val:
        x = x.flatten()
        print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
            np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x)))


def mkdirs(paths):
    """create empty directories if they don't exist

    Parameters:
        paths (str list) -- a list of directory paths
    """
    if isinstance(paths, list) and not isinstance(paths, str):
        for path in paths:
            mkdir(path)
    else:
        mkdir(paths)


def mkdir(path):
    """create a single empty directory if it didn't exist

    Parameters:
        path (str) -- a single directory path
    """
    if not os.path.exists(path):
        os.makedirs(path)

def print_losses(epoch, iters, len_dataset, current_losses, average_losses, mode='training'):
    """print current losses on console"""
    if mode=='training':
        message = mode + ': (epoch: %d, iters: %d / %d) ' % (epoch, iters, len_dataset)
    else:
        message = mode + ': (epoch: %d) ' % epoch
    for k, v in current_losses.items():
        message += '%s: %.3f ' % (k, v)
    for k, v in average_losses.items():
        message += 'average %s: %.3f ' % (k, v.avg())
    message += datetime.datetime.now().strftime("%Y_%m_%d %H:%M:%S")
    print(message)  # print the message

def make_grid(model):
    """
    create an image grid to be visualized by tensorboard.
    """
    visuals = model.get_current_visuals()
    names, grids = [], []
    for name, img in visuals.items():
        names.append(name)
        grid = torchvision.utils.make_grid(img[:,:3,:,:], nrow=img.size()[0], normalize=True)
        grids.append(grid)
    return grids, names

class AverageMeter:
    def __init__(self):
        self.sum = 0
        self.num_item = 0

    def update(self, value):
        self.sum += value
        self.num_item += 1

    def avg(self):
        return self.sum / self.num_item

    def clear(self):
        self.sum = 0
        self.num_item = 0