from inspect import _ParameterKind
import SimpleITK as sitk
import tensorflow as tf
from tensorflow.keras.models import load_model
from focal_loss import BinaryFocalLoss
import numpy as np
import multiprocessing
from functools import partial
import os 
from os import path
from tqdm import tqdm
import argparse

from sfransen.utils_quintin import * 
from sfransen.DWI_exp.helpers import *
from sfransen.DWI_exp.preprocessing_function import preprocess  
from sfransen.DWI_exp.callbacks import dice_coef
#from sfransen.FROC.blob_preprocess import *
from sfransen.FROC.cal_froc_from_np import *
from sfransen.load_images import load_images_parrallel
from sfransen.DWI_exp.losses import weighted_binary_cross_entropy
from umcglib.froc import *
from umcglib.binarize import dynamic_threshold


def print_p(*args, **kwargs):
    """
    Shorthand for print(..., flush=True)
    Useful on HPC cluster where output has buffered writes.
    """
    print(*args, **kwargs, flush=True)   


######## CUDA ################
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
N_CPUS = 12


DATA_DIR = "./../data/Nijmegen paths/"
TARGET_SPACING = (0.5, 0.5, 3) 
INPUT_SHAPE = (192, 192, 24, 3)
IMAGE_SHAPE = INPUT_SHAPE[:3]

final_table = {}
difference = {}
for fold in range(5):

    DATA_SPLIT_INDEX = read_yaml_to_dict(f'./../data/Nijmegen paths/train_val_test_idxs_{fold}.yml')
    TEST_INDEX = DATA_SPLIT_INDEX['test_set0']

    for img_idx in TEST_INDEX:

        for model in ['b800','b400']:
            
            image_paths = {}
            predictions_added = []
            segmentations_added = []
            images = []
            images_list = []
            segmentations = []
        
            if model is 'b800':
                MODEL_PATH = f'./../train_output/calc_exp_t2_b1400calc2_adccalc2_{fold}/models/calc_exp_t2_b1400calc2_adccalc2_{fold}.h5'
                # YAML_DIR = f'./../train_output/calc_exp_t2_b1400calc2_adccalc2_{fold}'
                # IMAGE_DIR = f'./../train_output/calc_exp_t2_b1400calc2_adccalc2_{fold}'
                SERIES = ['t2','b1400calc2','adccalc2']
            if model is 'b400':
                MODEL_PATH = f'./../train_output/calc_exp_t2_b1400calc3_adccalc3_{fold}/models/calc_exp_t2_b1400calc3_adccalc3_{fold}.h5'
                SERIES = ['t2','b1400calc3','adccalc3']

            for s in SERIES:
                with open(path.join(DATA_DIR, f"{s}.txt"), 'r') as f:
                    image_paths[s] = [l.strip() for l in f.readlines()]
            with open(path.join(DATA_DIR, f"seg.txt"), 'r') as f:
                seg_paths = [l.strip() for l in f.readlines()]
            num_images = len(seg_paths)

            pat_id = os.path.basename(os.path.normpath(seg_paths[img_idx]))[:-7] 

            # print_p("pat_idx:",pat_id)

            # print(image_paths['t2'][])
            # input('check?')
            # Read and preprocess each of the paths for each series, and the segmentations.
                # print('images number',[TEST_INDEX[img_idx]])
            img_s = {f'{s}': sitk.ReadImage(image_paths[s][img_idx], sitk.sitkFloat32) for s in SERIES}
            seg_s = sitk.ReadImage(seg_paths[img_idx], sitk.sitkFloat32)
            img_n, seg_n = preprocess(img_s, seg_s, 
                shape=IMAGE_SHAPE, spacing=TARGET_SPACING)
            for seq in img_n:
                images.append(img_n[f'{seq}'])
            images_list.append(images)
            images = []
            segmentations.append(seg_n)

            images_list = np.transpose(images_list, (0, 2, 3, 4, 1))

            ########### load module ##################
            # print(' >>>>>>> LOAD MODEL <<<<<<<<<')

            dependencies = {
                'dice_coef': dice_coef,
                'weighted_cross_entropy_fn':weighted_binary_cross_entropy
            }
            reconstructed_model = load_model(MODEL_PATH, custom_objects=dependencies)
            # reconstructed_model.summary(line_length=120)

            # make predictions on all TEST_INDEX
            # print(' >>>>>>> START prediction <<<<<<<<<')
            predictions_blur = reconstructed_model.predict(images_list, batch_size=1)

            ############# preprocess ################# 
            # preprocess predictions by removing the blur and making individual blobs 
            # print('>>>>>>>> START preprocess')
            def move_dims(arr):
                # UMCG numpy dimensions convention: dims = (batch, width, heigth, depth)
                # Joeran numpy dimensions convention: dims = (batch, depth, heigth, width)
                arr = np.moveaxis(arr, 3, 1) 
                arr = np.moveaxis(arr, 3, 2)
                return arr

            # Joeran has his numpy arrays ordered differently.
            predictions_blur = move_dims(np.squeeze(predictions_blur,axis=4))
            segmentations = move_dims(segmentations)
            # predictions = [preprocess_softmax(pred, threshold="dynamic")[0] for pred in predictions_blur]
            predictions = predictions_blur
            # print("the size of predictions is:",np.shape(predictions))
            # Remove outer edges 
            zeros = np.zeros(np.shape(predictions))
            test = predictions[:,2:-2,2:190,2:190]
            zeros[:,2:-2,2:190,2:190] = test
            predictions = zeros

            #make list of worst patient predictions


            if model is 'b800':
                final_table[pat_id] = [np.max(predictions)]
                print_p(f'Max prediction of {pat_id} in b800 is {np.max(predictions)}')
            if model is 'b400':
                final_table[pat_id].append(np.max(predictions))
                print_p(f'Max prediction of {pat_id} in b400 is {np.max(predictions)}')

        difference[pat_id] = abs(np.diff(final_table[pat_id]))
        sorted_difference = {k: v for k, v in sorted(difference.items(), key=lambda item: item[1])}
        print_p(f'>>{fold}<<',sorted_difference)


sorted_differences = {k: v for k, v in sorted(difference.items(), key=lambda item: item[1])}
print_p('>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
print_p(sorted_differences)
print_p(sorted_differences[::-1])