from jenti.patch import Patch
import numpy as np
import random

def choose_fg_idx(
        patch_mask, # an nd-array with size patch_H x patch_W or patch_H x patch_W x patch_Ch
        fg_idx:list, # list of foreground indices. e.g. [2, 4, 7, 9]
        MAX_ROI:bool=True, # if true and the returned patch is a foreground patch, then it
                           # returns the patch that has maximum info or region of interest (roi) 
        ):
    """ 
    It is a helper function that picks a foreground index. If MAX_ROI is True,
    then it returns the index of that patch that has max info or roi in it. Otherwise,
    it returns a randomly chosen foreground index.
    
    Return
    --------
    It returns a foreground index. 
    """
    if MAX_ROI: # pick the index of the foreground patch that has maximum roi     
    
        max_nonzeros = 0 # Maximum no. of nonzeros. Initially set it to 0.
        final_fg_idx: int # index of the patch that has maximum roi
        
        for idx in fg_idx:
            
            x = patch_mask[idx] # get the foreground patch mask
            
            n_nonzero = np.count_nonzero(x) # no. of nonzeros in the patch mask
            
            # Compare with current max no. of nonzeros
            if n_nonzero > max_nonzeros: 
                final_fg_idx = idx # update index if new count is higher than the previous count
                max_nonzeros = n_nonzero # update max no. of nonzeros
                
        return final_fg_idx 
        
    else: # randomly pick a foreground index
        return random.choice(fg_idx)
        

def runtime_patch(
        image, # an nd-array with size H x W or H x W x Ch
        mask, # an nd-array with size H x W or H x W x Ch
        patch_shape:tuple=(256,256), # patch size
        overlap:tuple=(0,0), # overlap between adjacent patches
        FG_PROB:float=0.9, # probability of choosing a foreground
        MAX_ROI:bool=True, # if true and the returned patch is a foreground patch, then it
                           # returns the patch that has maximum info or region of interest (roi) 
        ):
    
    """
    This function returns an image patch and the corresponding mask patch. The patch
    can be a background patch or a foreground patch.
    
        foreground patch: It contains information or region of interest (roi)
        background patch: It does not contain any info or roi
        
    Return
    --------
    It returns an image patch and the corresponding mask patch. 
    Size of image/mask patch: (patch_H, patch_W, ch) or (patch_H, patch_W)
    """
    
    patch = Patch(patch_shape, overlap, patch_name='patch2d', csv_output=False)
    patch_img, _, _ = patch.patch2d(image)
    patch_mask, _, _ = patch.patch2d(mask)
    
    # Separate foreground (fg) and background
    fg_idx, bg_idx = [], []
    
    for i,x in enumerate(patch_mask):
        if np.sum(x) > 0: fg_idx.append(i) # fg
        else: bg_idx.append(i)  # background
    
    # If no foreground, then randomly return a background patch
    if len(fg_idx) == 0: 
        
        # Randomly choose a bg index
        final_bg_idx = random.choice(bg_idx)
        
        return patch_img[final_bg_idx], patch_mask[final_bg_idx]
    
    # If no background, then randomly return a foreground patch
    if len(bg_idx) == 0:
        
        final_fg_idx = choose_fg_idx(patch_mask, fg_idx, MAX_ROI)
        
        return patch_img[final_fg_idx], patch_mask[final_fg_idx]
       
    # Choose foreground or background based on a probability distribution
    fg_flag: bool
    fg_flag = True if np.random.uniform(low=0, high=1, size=1) <= FG_PROB else False
        
    if fg_flag: # pick a foreground patch
    
        final_fg_idx = choose_fg_idx(patch_mask, fg_idx, MAX_ROI)
            
        return patch_img[final_fg_idx], patch_mask[final_fg_idx]
        
    else: # pick a background

        final_bg_idx = random.choice(bg_idx)
        
        return patch_img[final_bg_idx], patch_mask[final_bg_idx]        

# =============================================================================
# # Example 
#         
# import cv2
# import matplotlib.pyplot as plt
# import os
# import random
# 
# # Parameters
# FG_PROB = 0.9 # probability of selecting a foreground image
# MAX_ROI = True # select the patch that has maximum roi 
# 
# # Directory
# img_dir = r'.\dataset\test\images'
# mask_dir = r'.\dataset\test\labels'
# 
# # List of images
# names = os.listdir(img_dir)
# 
# name = random.choice(names)
# 
# # Read image
# image = cv2.imread(os.path.join(img_dir, name))[:,:,::-1]
# mask = cv2.imread(os.path.join(mask_dir, name), 0)
# 
# mask = np.expand_dims(mask, axis=-1)
# 
# # Create patches
# patch_shape = [256, 256]
# overlap = [10,10] # overlap between two adjacent patches along both axes
#         
# ip, mp = runtime_patch(
#         image, 
#         mask, 
#         patch_shape=(256,256), 
#         overlap=(0,0), 
#         FG_PROB=0.9, 
#         MAX_ROI=True)  
# 
# 
# 
# fig, ax = plt.subplots(2,1, figsize=(15,7))
# ax[0].imshow(ip)
# ax[1].imshow(mp, cmap='gray')
# 
# =============================================================================