import numpy as np
import torch
import os
from easyfsl.datasets.few_shot_dataset import FewShotDataset
from PIL import Image
import matplotlib.pyplot as plt




class Jammer_Dataset(FewShotDataset):
    def __init__(self,data_root,dataset_list,transform =None,mode = "train"):
        self.data_root = data_root
        self.transform =transform
        self.dataset = dataset_list 
        self.class_names = np.unique([item[1] for item in self.dataset])
        #print(f"dataset classes are -------------------------------------------{self.dataset[1][1]}")
        print(f"classes are ====================================================={self.class_names}")
        self.class_to_label = {v: k for k, v in enumerate(sorted(self.class_names))}
        print(f"mapping is ---------------------------------------------------{self.class_to_label}")
        self.labels = self.get_labels()

  
    def __len__(self):
        return len(self.dataset)
    
    def __getitem__(self,idx):

        samples = str(self.dataset[idx][0])
        img_array = np.load(os.path.join(samples))
        img_array = torch.from_numpy(img_array)
        rgb_tensor = torch.stack((img_array, img_array, img_array), dim=0)
        img_array = rgb_tensor.permute(0,2,1)
        #img_array = img_array[:, int(npy_number):int(npy_number)+243]
            
        # print(x_row_flip_0.shape)

        # fig, axs = plt.subplots(1, 2, figsize=(10, 5))

        # # Original Image
        # axs[0].imshow(img_array)
        # axs[0].set_title('Original Image')

        # # Flipped Image
        # axs[1].imshow(x_row_flip_0.numpy())
        # axs[1].set_title(f"Flipped Image_{aug_num}")
        
        # # Save the figures
        # plt.savefig(f"original_image_{idx}.png", bbox_inches='tight')
        # plt.savefig(f"flipped_image_{idx}.png", bbox_inches='tight')

        # Create a 3-channel tensor by repeating the single-channel data

        return img_array.float(),  self.labels[idx]

    
    def get_labels(self):
        return [self.class_to_label[label] for _, label in self.dataset]





def augment_sample(image_path, transforms):
    # Load the image
    image = Image.open(image_path)
    augmented_image = transforms(image)
    augmented_image = transforms.ToTensor()(augmented_image) 
    return augmented_image


def augment_data(data, augmentation_transforms, augmentation_factor):
    augmented_data = []
    augmented_labels = []

    for filename, label in data:
        for _ in range(augmentation_factor):
            augmented_sample = augment_sample(filename, augmentation_transforms)
            augmented_data.append((augmented_sample, label))
            augmented_labels.append(label)

    return data + augmented_data




def balance_data(n_shot, n_query, data):

    print(f"minimum required sample size is {n_shot} + {n_query}")

    # Count the number of samples per label in train_data
    label_counts_train = {}
    for _, label in data:
        if label in label_counts_train:
            label_counts_train[label] += 1
        else:
            label_counts_train[label] = 1

    # print(label_counts_train)

    # print("--------------------started iterating-------------------------------------")

    max_repeat = n_shot+n_query
    repeats = {}

    for key, value in label_counts_train.items():
        num_repeats = max(0, max_repeat - value)
        if num_repeats > 0:
            repeats[key] = num_repeats
    #print(f"the reapets are emmkk=====================>>>>>>{repeats}")
    repeated_data = []

    for label, num_repeats in repeats.items():
        label_data = [(filename, label) for filename, data_label in data if data_label == label]
        print(f"current procedure running for label {label}")
        if len(label_data) > num_repeats:
            repeated_data.extend(label_data[:num_repeats+1])
            # print(label_data[:num_repeats])
            # print("im working")
        else:
            # print(num_repeats)  
            #repeated_data.extend([item for item in label_data for _ in range(num_repeats)])
            repeated_data.extend(label_data * (num_repeats+1))
            # print("else im working")
        # print(repeated_data)
    # print(repeats)
    # print(repeated_data[0])

    data.extend(repeated_data)

    balanced_label_counts = {}
    for _, label in data:
        if label in balanced_label_counts:
            balanced_label_counts[label] += 1
        else:
            balanced_label_counts[label] = 1

    print("Label counts in the balanced data:")
    print(balanced_label_counts)
    return data