import os
import argparse
import ast
import time
from mindspore import context
from mindspore import Tensor
from mindspore.nn.optim.momentum import Momentum
from mindspore.train.model import Model
from mindspore.context import ParallelMode
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor, Callback
from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
from mindspore.train.loss_scale_manager import FixedLossScaleManager
from mindspore.nn.metrics import Accuracy, Top1CategoricalAccuracy, Loss
from mindspore.train.serialization import load_checkpoint, load_param_into_net
from mindspore.communication.management import init, get_rank, get_group_size
from mindspore.common import set_seed
import mindspore.nn as nn
import mindspore.common.initializer as weight_init
from src.lr_generator import get_lr, warmup_cosine_annealing_lr
from src.CrossEntropySmooth import CrossEntropySmooth

parser = argparse.ArgumentParser(description='Image classification')
parser.add_argument('--net', type=str, default=None, help='Resnet Model, either resnet50 or resnet101')
parser.add_argument('--dataset', type=str, default=None, help='Dataset, either cifar10 or imagenet2012')
parser.add_argument('--run_distribute', type=ast.literal_eval, default=False, help='Run distribute')
parser.add_argument('--device_num', type=int, default=1, help='Device num.')
parser.add_argument('--dataset_path', type=str, default=None, help='Dataset path')
parser.add_argument('--device_target', type=str, default='Ascend', help='Device target')
parser.add_argument('--batch_size', type=int, default=256, help='batch size')
parser.add_argument('--pre_trained', type=str, default=None, help='Pretrained checkpoint path')
parser.add_argument('--parameter_server', type=ast.literal_eval, default=False, help='Run parameter server train')
args = parser.parse_args()

set_seed(1)

class MetricMeter(Callback):

    def __init__(self, model, eval_dataset, batch_size):
        super(MetricMeter, self).__init__()
        self.model = model
        self.eval_dataset = eval_dataset
        self.batch_size = batch_size
    
    def begin(self, run_context):
        self.start = time.time()
        print(f"model start ts: {self.start}")
    
    def end(self, run_context):
        end = time.time()
        duration = end - self.start
        print(f"model end time: {end}")
        print(f"total duration: {duration } s")
        print(f"total duration: {duration / (60)} min")
    
    def epoch_begin(self, run_context):
        self.epoch_start_time = time.time()

    def epoch_end(self, run_context):
        epoch_time = (time.time() - self.epoch_start_time)
        cb_params = run_context.original_args()

        throughput = self.batch_size * cb_params.batch_num / epoch_time
        
        # metrics is a dict
        metrics = self.model.eval(self.eval_dataset, dataset_sink_mode=False)
        top1 = metrics['top1']
        val_loss = metrics['loss']

        print(f"[metrics] epoch: {cb_params.cur_epoch_num}, walltime: {time.time()}, epoch_time:{epoch_time:.0f}, fps: {throughput:.5f}, val_acc1: {top1:.5f}, val_loss: {val_loss:.5f}", flush=True)

if args.net == "resnet50":
    from src.resnet import resnet50 as resnet
    if args.dataset == "cifar10":
        from src.config import config1 as config
        from src.dataset import create_dataset1 as create_dataset
    else:
        from src.config import config2 as config
        from src.dataset import create_dataset2 as create_dataset
elif args.net == "resnet101":
    from src.resnet import resnet101 as resnet
    from src.config import config3 as config
    from src.dataset import create_dataset3 as create_dataset
else:
    from src.resnet import se_resnet50 as resnet
    from src.config import config4 as config
    from src.dataset import create_dataset4 as create_dataset


if __name__ == '__main__':
    target = args.device_target
    config.batch_size = args.batch_size
    ckpt_save_dir = config.save_checkpoint_path

    # init context
    context.set_context(mode=context.GRAPH_MODE, device_target=target, save_graphs=False)
    if args.parameter_server:
        context.set_ps_context(enable_ps=True)
    if args.run_distribute:
        if target == "Ascend":
            device_id = int(os.getenv('DEVICE_ID'))
            context.set_context(device_id=device_id, enable_auto_mixed_precision=True)
            context.set_auto_parallel_context(device_num=args.device_num, parallel_mode=ParallelMode.DATA_PARALLEL,
                                              gradients_mean=True)
            if args.net == "resnet50" or args.net == "se-resnet50":
                context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160])
            else:
                context.set_auto_parallel_context(all_reduce_fusion_config=[180, 313])
            init()
        # GPU target
        else:
            init()
            context.set_auto_parallel_context(device_num=get_group_size(), parallel_mode=ParallelMode.DATA_PARALLEL,
                                              gradients_mean=True)
            if args.net == "resnet50":
                context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160])
        ckpt_save_dir = config.save_checkpoint_path + "ckpt_" + str(get_rank()) + "/"

    # create dataset
    dataset = create_dataset(dataset_path=os.path.join(args.dataset_path, "train"), do_train=True, repeat_num=1,
                             batch_size=config.batch_size, target=target)
    eval_dataset = create_dataset(dataset_path=os.path.join(args.dataset_path, "val"), do_train=False,
                             batch_size=config.batch_size, target=target)
    step_size = dataset.get_dataset_size()

    # define net
    net = resnet(class_num=config.class_num)
    if args.parameter_server:
        net.set_param_ps()

    # init weight
    if args.pre_trained:
        param_dict = load_checkpoint(args.pre_trained)
        load_param_into_net(net, param_dict)
    else:
        for _, cell in net.cells_and_names():
            if isinstance(cell, nn.Conv2d):
                cell.weight.set_data(weight_init.initializer(weight_init.XavierUniform(),
                                                             cell.weight.shape,
                                                             cell.weight.dtype))
            if isinstance(cell, nn.Dense):
                cell.weight.set_data(weight_init.initializer(weight_init.TruncatedNormal(),
                                                             cell.weight.shape,
                                                             cell.weight.dtype))

    # init lr
    if args.net == "resnet50" or args.net == "se-resnet50":
        lr = get_lr(lr_init=config.lr_init, lr_end=config.lr_end, lr_max=config.lr_max,
                    warmup_epochs=config.warmup_epochs, total_epochs=config.epoch_size, steps_per_epoch=step_size,
                    lr_decay_mode=config.lr_decay_mode)
    else:
        lr = warmup_cosine_annealing_lr(config.lr, step_size, config.warmup_epochs, config.epoch_size,
                                        config.pretrain_epoch_size * step_size)
    lr = Tensor(lr)

    # define opt
    decayed_params = []
    no_decayed_params = []
    for param in net.trainable_params():
        if 'beta' not in param.name and 'gamma' not in param.name and 'bias' not in param.name:
            decayed_params.append(param)
        else:
            no_decayed_params.append(param)

    group_params = [{'params': decayed_params, 'weight_decay': config.weight_decay},
                    {'params': no_decayed_params},
                    {'order_params': net.trainable_params()}]
    opt = Momentum(group_params, lr, config.momentum, loss_scale=config.loss_scale)
    # define loss, model
    if target == "Ascend":
        if args.dataset == "imagenet2012":
            if not config.use_label_smooth:
                config.label_smooth_factor = 0.0
            loss = CrossEntropySmooth(sparse=True, reduction="mean",
                                      smooth_factor=config.label_smooth_factor, num_classes=config.class_num)
        else:
            loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
        loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False)
        model = Model(net, loss_fn=loss, optimizer=opt, loss_scale_manager=loss_scale, metrics={"top1": Top1CategoricalAccuracy(), "loss": Loss()},
                      amp_level="O2", keep_batchnorm_fp32=False)
    else:
        # GPU target
        if args.dataset == "imagenet2012":
            if not config.use_label_smooth:
                config.label_smooth_factor = 0.0
            loss = CrossEntropySmooth(sparse=True, reduction="mean",
                                      smooth_factor=config.label_smooth_factor, num_classes=config.class_num)
        else:
            loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")

        if (args.net == "resnet101" or args.net == "resnet50") and not args.parameter_server:
            opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, config.momentum, config.weight_decay,
                           config.loss_scale)
            loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False)
            # Mixed precision
            # 1.1.1 to eval the model, we must set keep_batchnorm_fp32=True
            model = Model(net, loss_fn=loss, optimizer=opt, loss_scale_manager=loss_scale, metrics={"top1": Top1CategoricalAccuracy(), "loss": Loss()},
                          amp_level="O2", keep_batchnorm_fp32=True)
        else:
            ## fp32 training
            opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, config.momentum, config.weight_decay)
            model = Model(net, loss_fn=loss, optimizer=opt, metrics={"top1": Top1CategoricalAccuracy(), "loss": Loss()})

    # define callbacks
    metric_cb = MetricMeter(model=model,eval_dataset=eval_dataset, batch_size=config.batch_size)
    cb = [metric_cb]
    
    # save_checkpoint
    # if config.save_checkpoint:
    #     if int(os.getenv("DEVICE_ID"), 0) == 0:
    #         config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_epochs * step_size,
    #                                      keep_checkpoint_max=config.keep_checkpoint_max)
    #         ckpt_cb = ModelCheckpoint(prefix="resnet", directory=ckpt_save_dir, config=config_ck)
    #         cb += [ckpt_cb]
    # train model
    if args.net == "se-resnet50":
        config.epoch_size = config.train_epoch_size
    model.train(config.epoch_size - config.pretrain_epoch_size, dataset, callbacks=cb,
                sink_size=dataset.get_dataset_size(), dataset_sink_mode=(not args.parameter_server))