import os
import io
import pickle
import copy
from collections import Counter
from pathlib import Path
from tempfile import NamedTemporaryFile
import regex as re
import numpy as np
import pandas as pd
from sklearn.manifold import TSNE
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import torch
from tqdm import tqdm
from PIL import Image
from transformers import AutoProcessor, AutoModel
import streamlit as st
from .data_loading import load_multiple_annotations, load_multiple_annotations_io
from .data_processing import generate_label_array
from .seqIo import seqIo_reader
from .mp4Io import mp4Io_reader

SLIP_MODEL_ID = "google/siglip-so400m-patch14-384"
CLIP_MODEL_ID = "openai/clip-vit-base-patch32"

def create_annot_fname_dict(annot_fnames: list[str])-> dict:
    fs = re.compile(r'.*(_\d+)$')

    unique_files = set()
    for file in annot_fnames:
        file_name = os.fsdecode(file)
        base_name, _ = os.path.splitext(file_name)
        if fs.match(base_name):
            ind = len(fs.match(base_name).group(1))
            unique_files.add(base_name[:-ind])
        else:
            unique_files.add(base_name)
    
    annot_fname_dict = {}
    for unique_file in unique_files:
        annot_fname_dict.update({unique_file: [file for file in annot_fnames if unique_file in file]})
    return annot_fname_dict

def create_annot_fname_dict_io(annot_fnames: list[str], annot_files: list)-> dict:
    annot_file_dict = {}
    for file in annot_files:
        annot_file_dict.update({file.name : file})
    fs = re.compile(r'.*(_\d+)$')

    unique_files = set()
    for file in annot_fnames:
        file_name = os.fsdecode(file)
        base_name, _ = os.path.splitext(file_name)
        if fs.match(base_name):
            ind = len(fs.match(base_name).group(1))
            unique_files.add(base_name[:-ind])
        else:
            unique_files.add(base_name)
    
    annot_fname_dict = {}
    for unique_file in unique_files:
        annot_list = [file for file in annot_fnames if unique_file in file]
        annot_list.sort()
        annot_file_list = [annot_file_dict[annot_file_name] for annot_file_name in annot_list]
        annot_fname_dict.update({unique_file: annot_file_list})
    return annot_fname_dict

def get_io_reader(uploaded_file):
    assert uploaded_file.name[-3:]=='seq', 'Not a seq file'
    with NamedTemporaryFile(suffix="seq", delete=False) as temp:
        temp.write(uploaded_file.getvalue())
        sr = seqIo_reader(temp.name)
    return sr

def load_slip_model(device):
    return AutoModel.from_pretrained(SLIP_MODEL_ID).to(device)

def load_slip_preprocessor():
    return AutoProcessor.from_pretrained(SLIP_MODEL_ID)

def load_clip_model(device):
    return AutoModel.from_pretrained(CLIP_MODEL_ID).to(device)

def load_clip_preprocessor():
    return AutoProcessor.from_pretrained(CLIP_MODEL_ID)

def encode_image(image, device, model, processor):
    with torch.no_grad():
        #convert_models_to_fp32(model)
        inputs = processor(images=image, return_tensors="pt").to(device)
        image_features = model.get_image_features(**inputs)
    return image_features.cpu().numpy().flatten()

def generate_embeddings_stream(fnames : list[str],
                        model = 'SLIP',
                        downsample_rate = 4,
                        save_csv = False)-> tuple[list, list, list]:
    # set up model and device
    device = "cuda" if torch.cuda.is_available() else "cpu"
    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
    if model == 'SLIP':
        embed_model = load_slip_model(device)
        processor = load_slip_preprocessor()
    elif model == 'CLIP':
        embed_model = load_clip_model(device)
        processor = load_clip_preprocessor()

    all_video_embeddings = []
    all_video_frames = []
    for fname in fnames:
        # read in file
        is_seq = False
        if fname[-3:] == 'seq': is_seq = True
        
        if is_seq:
            sr = seqIo_reader(fname)
        else:
            sr = mp4Io_reader(fname)
        N  = sr.header['numFrames']

        # set up embeddings and frame arrays
        embeddings = []
        frames = list(range(N))[::downsample_rate]
        print(frames)

        # create progress bar
        i = 0
        pbar_text = lambda i: f'Creating embeddings for {fname}. {i}/{len(frames)} frames.'
        pbar = st.progress(0, text=pbar_text(0))

        # convert each frame to embeddings
        for f in tqdm(frames):
            img, _ = sr.getFrame(f)
            img_arr = np.array(img)
            if is_seq:
                img_rgb = Image.fromarray(img_arr, 'L').convert('RGB')
            else:
                img_rgb = Image.fromarray(img_arr).convert('RGB')

            embeddings.append(encode_image(img_rgb, device, embed_model, processor))

            # update progress bar
            i += 1
            pbar.progress(i/len(frames), pbar_text(i))

        # save csv of single file
        if save_csv:
            df = pd.DataFrame(embeddings)
            df['Frame'] = frames

            # save csv
            basename = Path(fname).stem
            df.to_csv(f'{basename}_embeddings_downsample_{downsample_rate}.csv', index=False)

        all_video_embeddings.append(np.array(embeddings))
        all_video_frames.append(frames)
    return all_video_embeddings, all_video_frames

def get_io_reader(uploaded_file):
    if uploaded_file.name[-3:]=='seq':
        with NamedTemporaryFile(suffix="seq", delete=False) as temp:
            temp.write(uploaded_file.getvalue())
            sr = seqIo_reader(temp.name)
    else:
        with NamedTemporaryFile(suffix="mp4", delete=False) as temp:
            temp.write(uploaded_file.getvalue())
            sr = mp4Io_reader(temp.name)
    return sr

def generate_embeddings_stream_io(uploaded_files : list,
                                model = 'SLIP',
                                downsample_rate = 4,
                                save_csv = False)-> tuple[list, list, list]:
    # set up model and device
    device = "cuda" if torch.cuda.is_available() else "cpu"
    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
    with st.spinner('Loading multimodal model...'):
        if model == 'SLIP':
            embed_model = load_slip_model(device)
            processor = load_slip_preprocessor()
        elif model == 'CLIP':
            embed_model = load_clip_model(device)
            processor = load_clip_preprocessor()

    all_video_embeddings = []
    all_video_frames = []
    for file in uploaded_files:
        is_seq = False
        if file.name[-3:] == 'seq': is_seq = True

        # read in file
        sr = get_io_reader(file)
        N  = sr.header['numFrames']

        # set up embeddings and frame arrays
        embeddings = []
        frames = list(range(N))[::downsample_rate]
        print(frames)

        # create progress bar
        i = 0
        pbar_text = lambda i: f'Creating embeddings for {file.name}. {i}/{len(frames)} frames.'
        pbar = st.progress(0, text=pbar_text(0))

        # convert each frame to embeddings
        for f in tqdm(frames):
            img, _ = sr.getFrame(f)
            img_arr = np.array(img)
            if is_seq:
                img_rgb = Image.fromarray(img_arr, 'L').convert('RGB')
            else:
                img_rgb = Image.fromarray(img_arr).convert('RGB')

            embeddings.append(encode_image(img_rgb, device, embed_model, processor))

            # update progress bar
            i += 1
            pbar.progress(i/len(frames), pbar_text(i))

        # save csv of single file
        if save_csv:
            df = pd.DataFrame(embeddings)
            df['Frame'] = frames

            # save csv
            df.to_csv(f'embeddings_downsample_{downsample_rate}_{N}_frames.csv', index=False)

        all_video_embeddings.append(np.array(embeddings))
        all_video_frames.append(frames)
    return all_video_embeddings, all_video_frames

def create_embeddings_csv(out: str,
                          fnames: list[str],
                          embeddings: list[np.ndarray],
                          frames: list[list[int]],
                          annotations: list[list[str]],
                          test_fnames: None | list[str],
                          views: None | list[str],
                          conditions: None | list[str],
                          downsample_rate = 4,
                          filesystem = None):
    """
    Creates a .csv file containing all of the generated embeddings and provived information.

    Parameters:
    -----------
    out : str
        The name of the resulting file.
    fnames : list[str]
        Video sources for each of the embedding arrays.
    embeddings : np.ndarray
        The generated embeddings from the images.
    downsample_rate : int
        The downsample_rate used for generating the embeddings.
    """
    assert len(fnames) == len(embeddings)
    assert len(embeddings) == len(frames)
    all_embeddings = np.vstack(embeddings)
    df = pd.DataFrame(all_embeddings)
    
    labels = []
    for i, annot_fnames in enumerate(annotations):
        _, ext = os.path.splitext(annot_fnames[0])
        if ext == '.annot':
            annot, _, _, sr = load_multiple_annotations(annot_fnames, filesystem=filesystem)
            annot_labels = generate_label_array(annot, downsample_rate, len(frames[i]))
        elif ext == '.csv':
            if not filesystem: 
                annot_df = pd.read_csv(annot_fnames[0], header=None)
            else:
                with filesystem.open(annot_fnames[0], 'r') as csv_file:
                    annot_df = pd.read_csv(csv_file, header=None)
            annot_labels = annot_df[0].to_list()[::downsample_rate]
            assert len(annot_labels) == len(frames[i]), "There is a mismatch between the number of frames and number of labels. Make sure that the passed in csv file has no header."
        else:
            raise ValueError(f'Incompatible file for annotations used. Got a file of type "{ext}".')
        assert len(annot_labels) == len(frames[i]), "There is a mismatch between the number of frames and number of labels. Make sure you have passed in the correct files."
        print(annot_labels)
        labels.append(annot_labels)
    all_labels = np.hstack(labels)
    print(len(all_labels))
    df['Label'] = all_labels
    
    all_frames = np.hstack(frames)
    df['Frame'] = all_frames
    sources = [[fname for _ in range(len(frames[i]))] for i, fname in enumerate(fnames)]
    all_sources = np.hstack(sources)
    df['Source'] = all_sources

    if test_fnames:
        t_split = lambda x: True if x in test_fnames else False
        test = [[t_split(fname) for _ in range(len(frames[i]))] for i, fname in enumerate(fnames)]
    else:
        test = [[True for _ in range(len(frames[i]))] for i, _ in enumerate(fnames)]
    all_test = np.hstack(test)
    df['Test'] = all_test

    if views:
        view = [[views[i] for _ in range(len(frames[i]))] for i in range(len(fnames))]
    else:
        view = [[None for _ in range(len(frames[i]))] for i in range(len(fnames))]
    all_view = np.hstack(view)
    df['View'] = all_view
    
    if conditions:
        condition = [[conditions[i] for _ in range(len(frames[i]))] for i in range(len(fnames))]
    else:
        condition = [[None for _ in range(len(frames[i]))] for i in range(len(fnames))]
    all_condition = np.hstack(condition)
    df['Condition'] = all_condition
    return df

def create_embeddings_csv_io(out: str,
                          fnames: list[str],
                          embeddings: list[np.ndarray],
                          frames: list[list[int]],
                          annotations: list,
                          test_fnames: None | list[str],
                          views: None | list[str],
                          conditions: None | list[str],
                          downsample_rate = 4):
    """
    Creates a .csv file containing all of the generated embeddings and provived information.

    Parameters:
    -----------
    out : str
        The name of the resulting file.
    fnames : list[str]
        Video sources for each of the embedding arrays.
    embeddings : np.ndarray
        The generated embeddings from the images.
    downsample_rate : int
        The downsample_rate used for generating the embeddings.
    """
    assert len(fnames) == len(embeddings)
    assert len(embeddings) == len(frames)
    all_embeddings = np.vstack(embeddings)
    df = pd.DataFrame(all_embeddings)
    
    labels = []
    for i, uploaded_annots in enumerate(annotations):
        print(i)
        _, ext = os.path.splitext(uploaded_annots[0].name)
        if ext == '.annot':
            annot, _, _, sr = load_multiple_annotations_io(uploaded_annots)
            annot_labels = generate_label_array(annot, downsample_rate, len(frames[i]))
        elif ext == '.csv':
            annot_df = pd.read_csv(uploaded_annots[0], header=None)
            annot_labels = annot_df[0].to_list()[::downsample_rate]
            assert len(annot_labels) == len(frames[i]), "There is a mismatch between the number of frames and number of labels. Make sure that the passed in csv file has no header."
        else:
            raise ValueError(f'Incompatible file for annotations used. Got a file of type "{ext}".')
        assert len(annot_labels) == len(frames[i]), "There is a mismatch between the number of frames and number of labels. Make sure you have passed in the correct files."
        print(annot_labels)
        labels.append(annot_labels)
    all_labels = np.hstack(labels)
    print(len(all_labels))
    df['Label'] = all_labels
    
    all_frames = np.hstack(frames)
    df['Frame'] = all_frames
    sources = [[fname for _ in range(len(frames[i]))] for i, fname in enumerate(fnames)]
    all_sources = np.hstack(sources)
    df['Source'] = all_sources

    if test_fnames:
        t_split = lambda x: True if x in test_fnames else False
        test = [[t_split(fname) for _ in range(len(frames[i]))] for i, fname in enumerate(fnames)]
    else:
        test = [[True for _ in range(len(frames[i]))] for i, _ in enumerate(fnames)]
    all_test = np.hstack(test)
    df['Test'] = all_test

    if views:
        view = [[views[i] for _ in range(len(frames[i]))] for i in range(len(fnames))]
    else:
        view = [[None for _ in range(len(frames[i]))] for i in range(len(fnames))]
    all_view = np.hstack(view)
    df['View'] = all_view
    
    if conditions:
        condition = [[conditions[i] for _ in range(len(frames[i]))] for i in range(len(fnames))]
    else:
        condition = [[None for _ in range(len(frames[i]))] for i in range(len(fnames))]
    all_condition = np.hstack(condition)
    df['Condition'] = all_condition
    return df

def process_dataset_in_mem(embeddings_df: pd.DataFrame,
                    specified_classes=None,
                    classes_to_remove=None,
                    max_class_size=None,
                    animal_state=None,
                    view=None,
                    shuffle_data=False,
                    test_videos=None):
    """
    Processes output generated from embeddings paired with images and behavior labels.

    Parameters:
    -----------
    csv_path : str
        Path to the file containing the original data. This should contain embeddings,
        a column named `'Label'` and a column named `'Images'`.
    specified_classes : None | list[str]
        An optional input. Defines labels which should be kept as is in the `'Label'`
        column and which should be changed to a default `other` label.
    classes_to_remove : None | list[str]
        An optional input. Drops rows from the dataframe which contain a label in the
        list.
    max_class_size : None | int
        An optional input. Determines the maximum amount of rows a single label can
        appear in for each unique label in the `'Label'` column.
    animal_state : None | str
        An optional input. Drops rows from the dataframe which do not contain a match
        for `animal_state` in the text field within the `'Images'` column.
    view : None | str
        An optional input. Drops rows from the dataframe which do not contain a match
        for `view` in the text field within the `'Images'` column.
    shuffle_data : bool
        Determines wether the dataframe should have its rows shuffled.
    test_videos : None | list[str]
        An optional input. Determines what rows should be in the `test` dataframe, and
        which should be in the `train` dataframe. It drops rows from the respective
        dataframe by keeping or dropping rows which do not contain a match for a `str`
        in `test_videos` in the text field within the `'Images'` column, respectively.
    
    Returns:
    --------
    balanced_train_embeddings : pandas.DataFrame
        A processed dataframe whose rows contain the embeddings for each of the images
        at the corresponding index within `balanced_train_images`.
    balanced_train_labels : list[str]
        A list of labels for each of the images at the corresponing index within
        `balanced_train_images`.
    balanced_train_images: list[str]
        A list of paths to images with each image at an index corresponding to a label
        with the same index in `balanced_train_labels` and the same row index within
        `balanced_train_embeddings`.
    test_embeddings : pandas.DataFrame
        A processed dataframe whose rows contain the embeddings for each of the images
        at the corresponding index within `test_images`.
    test_labels : list[str]
        A list of labels for each of the images at the corresponing index within
        `test_images`.
    test_images : list[str]
        A list of paths to images with each image at an index corresponding to a label
        with the same index in `test_labels` and the same row index within
        `test_embeddings`.
    """
    # Convert embeddings, labels, and images to a DataFrame for easy manipulation
    df = copy.deepcopy(embeddings_df)
    df_keys = [str(x) for x in df.keys()]
    #Filter by fed or fasted
    if 'Condition' in df_keys and animal_state:
        df = df[df['Condition'].str.contains(animal_state, na=False)]

    if 'View' in df_keys and view:
        df = df[df['View'].str.contains(view, na=False)]

    # Extract unique video names excluding the frame number
    #unique_video_names = df['Images'].apply(lambda x: '_'.join(x.split('_')[:-1])).unique()
    #print("\nUnique video names:\n", unique_video_names)

    if classes_to_remove:
        df = df[~df['Label'].str.contains('|'.join(classes_to_remove), na=False)]
    elif classes_to_remove and 'all' in classes_to_remove:
        df = df[df['Label'].str.contains('|'.join(classes_to_remove), na=False)]

    # Further filter to include only specified_classes
    if specified_classes:
        single_match = lambda x: list(set(x.split('||')) & set(specified_classes))[0]
        df['Label'] = df['Label'].apply(lambda x: single_match(x) if not set(x.split('||')).isdisjoint(specified_classes) else 'other')
        specified_classes.append('other')

    # Separate the DataFrame into test and training sets based on test_videos
    if 'Test' in df_keys and test_videos:
        test_df = df[df['Test']]
        train_df = df[~df['Test']]
    elif test_videos:
        test_df = df[df['Images'].str.contains('|'.join(test_videos), na=False)]
        train_df = df[~df['Images'].str.contains('|'.join(test_videos), na=False)]
    else:
        test_df = pd.DataFrame(columns=df.columns)
        train_df = df
    
    # Print the number of frames in each class before balancing
    label_counts = train_df['Label'].value_counts()
    print("\nNumber of training frames in each class before balancing:")
    print(label_counts)
    
    if max_class_size:
        balanced_train_df = pd.concat([
            group.sample(n=min(len(group), max_class_size), random_state=1)
            for label, group in train_df.groupby('Label')
        ])
    else:
        balanced_train_df = train_df

    # Shuffle the training DataFrame
    if shuffle_data:
        balanced_train_df = balanced_train_df.sample(frac=1).reset_index(drop=True)
    
    # Convert training set back to numpy array and list
    if not "Images" in df_keys:
        balanced_train_embeddings = balanced_train_df.drop(columns=['Label', 'Frame', 'Source', 'Test','View','Condition']).to_numpy()
        balanced_train_labels = balanced_train_df['Label'].tolist()
        balanced_train_images = balanced_train_df['Frame'].tolist()
        
        # Convert test set back to numpy array and list
        test_embeddings = test_df.drop(columns=['Label', 'Frame', 'Source', 'Test','View','Condition']).to_numpy()
        test_labels = test_df['Label'].tolist()
        test_images = test_df['Frame'].tolist()
    else:
        # Convert training set back to numpy array and list
        balanced_train_embeddings = balanced_train_df.drop(columns=['Label', 'Images']).to_numpy()
        balanced_train_labels = balanced_train_df['Label'].tolist()
        balanced_train_images = balanced_train_df['Images'].tolist()
        
        # Convert test set back to numpy array and list
        if 'Test' in test_df:
            test_embeddings = test_df.drop(columns=['Label', 'Images', 'Test']).to_numpy()
        else:
            test_embeddings = test_df.drop(columns=['Label', 'Images']).to_numpy()

        test_labels = test_df['Label'].tolist()
        test_images = test_df['Images'].tolist()
    
    # Print the number of frames in each class after balancing
    if specified_classes or max_class_size:
        balanced_label_counts = Counter(balanced_train_labels)
        print("\nNumber of training frames in each class after balancing:")
        print(balanced_label_counts)

    test_label_counts = test_df['Label'].value_counts()
    # print("\nNumber of testing frames in each class:")
    print(test_label_counts)
    
    return balanced_train_embeddings, balanced_train_labels, balanced_train_images, test_embeddings, test_labels, test_images

def multiclass_merge_and_filter_bouts(multiclass_vector, bout_threshold, proximity_threshold):
    # Get the unique labels in the multiclass vector (excluding zero, assuming zero is the background/no label)
    unique_labels = np.unique(multiclass_vector)
    unique_labels = unique_labels[unique_labels != 0]

    # Initialize a vector to store the merged and filtered multiclass vector
    merged_vector = np.zeros_like(multiclass_vector)

    for label in unique_labels:
        # Create a binary vector for the current label
        binary_vector = (multiclass_vector == label)

        # Find the start and end indices of all sequences of 1's for this label
        starts = np.where(np.diff(np.concatenate(([0], binary_vector))) == 1)[0]
        ends = np.where(np.diff(np.concatenate((binary_vector, [0]))) == -1)[0]

        # Step 1: Merge close short bouts
        i = 0
        while i < len(starts) - 1:
            # Check if the gap between the end of the current bout and the start of the next bout
            # is within the proximity threshold
            if starts[i + 1] - ends[i] <= proximity_threshold:
                # Merge the two bouts by setting all elements between the start of the first
                # and the end of the second bout to 1
                binary_vector[ends[i]:starts[i + 1]] = 1
                # Remove the next bout from consideration
                starts = np.delete(starts, i + 1)
                ends = np.delete(ends, i)
            else:
                i += 1

        # Update the starts and ends after merging
        starts = np.where(np.diff(np.concatenate(([0], binary_vector))) == 1)[0]
        ends = np.where(np.diff(np.concatenate((binary_vector, [0]))) == -1)[0]

        # Step 2: Remove standalone short bouts
        for i in range(len(starts)):
            # Check the length of the bout
            length_of_bout = ends[i] - starts[i] + 1

            # If the length is less than the threshold, set those elements to 0
            if length_of_bout < bout_threshold:
                binary_vector[starts[i]:ends[i] + 1] = 0

        # Combine the binary vector with the merged_vector, ensuring only the current label is set
        merged_vector[binary_vector] = label

    # Return the filtered multiclass vector
    return merged_vector

def get_unique_labels(label_list: list[str]):
    label_set = set()
    for label in label_list:
        individual_labels = label.split('||')
        for individual_label in individual_labels:
            label_set.add(individual_label)
    return list(label_set)

def get_train_test_split(train_embeds, numerical_labels, test_size=0.05, random_state=42):
    return train_test_split(train_embeds, numerical_labels, test_size=test_size, random_state=random_state)

def train_model(X_train, y_train, random_state=42):
    # Train SVM Classifier
    svm_clf = SVC(kernel='rbf', random_state=random_state, probability=True)
    svm_clf.fit(X_train, y_train)
    return svm_clf

def pickle_model(model):
    pickled = io.BytesIO()
    pickle.dump(model, pickled)
    return pickled

def get_seq_io_reader(uploaded_file):
    assert uploaded_file.name[-3:]=='seq', 'Not a seq file'
    with NamedTemporaryFile(suffix="seq", delete=False) as temp:
        temp.write(uploaded_file.getvalue())
        sr = seqIo_reader(temp.name)
    return sr

def seq_to_arr(sr):
    N = sr.header['numFrames']
    images = []
    for f in range(N):
        I, ts = sr.getFrame(f)
        images.append(I)
    return np.array(images)

def get_2d_embedding(embeddings: pd.DataFrame):
    tsne = TSNE(n_jobs=4, n_components=2, random_state=42, perplexity=50)
    embedding_2d = tsne.fit_transform(np.array(embeddings))
    return embedding_2d