"""
DeepLabCut2.0 Toolbox (deeplabcut.org)
© A. & M. Mathis Labs
https://github.com/AlexEMG/DeepLabCut
Please see AUTHORS for contributors.

https://github.com/AlexEMG/DeepLabCut/blob/master/AUTHORS
Licensed under GNU Lesser General Public License v3.0
"""


import os, pickle, yaml
import pandas as pd
from pathlib import Path
import numpy as np

from deeplabcut.utils import auxiliaryfunctions

def convertcsv2h5(config,userfeedback=True,scorer=None):
    """
    Convert (image) annotation files in folder labeled-data from csv to h5.
    This function allows the user to manually edit the csv (e.g. to correct the scorer name and then convert it into hdf format).
    WARNING: conversion might corrupt the data.
    
    config : string
        Full path of the config.yaml file as a string.
    
    userfeedback: bool, optional
        If true the user will be asked specifically for each folder in labeled-data if the containing csv shall be converted to hdf format.
        
    scorer: string, optional
        If a string is given, then the scorer/annotator in all csv and hdf files that are changed, will be overwritten with this name. 
        
    Examples
    --------
    Convert csv annotation files for reaching-task project into hdf. 
    >>> deeplabcut.convertcsv2h5('/analysis/project/reaching-task/config.yaml')
    
    --------
    Convert csv annotation files for reaching-task project into hdf while changing the scorer/annotator in all annotation files to Albert!
    >>> deeplabcut.convertcsv2h5('/analysis/project/reaching-task/config.yaml',scorer='Albert')
    --------
    """
    cfg = auxiliaryfunctions.read_config(config)
    videos = cfg['video_sets'].keys()
    video_names = [Path(i).stem for i in videos]
    folders = [Path(config).parent / 'labeled-data' /Path(i) for i in video_names]
    if scorer==None:
        scorer=cfg['scorer']

    for folder in folders:
        try:
            if userfeedback==True:
                print("Do you want to convert the csv file in folder:", folder, "?")
                askuser = input("yes/no")
            else:
                askuser="yes"
            
            if askuser=='y' or askuser=='yes' or askuser=='Ja' or askuser=='ha': # multilanguage support :)
                fn=os.path.join(str(folder),'CollectedData_' + cfg['scorer'] + '.csv')
                data=pd.read_csv(fn)
                
                #nlines,numcolumns=data.shape
                
                orderofbpincsv=list(data.values[0,1:-1:2])
                imageindex=list(data.values[2:,0])
                
                #assert(len(orderofbpincsv)==len(cfg['bodyparts']))
                print(orderofbpincsv)
                print(cfg['bodyparts'])
                
                #TODO: test len of images vs. len of imagenames for another sanity check
                
                index = pd.MultiIndex.from_product([[scorer], orderofbpincsv, ['x', 'y']],names=['scorer', 'bodyparts', 'coords'])
                frame = pd.DataFrame(np.array(data.values[2:,1:],dtype=float), columns = index, index = imageindex)

                frame.to_hdf(os.path.join(str(folder),'CollectedData_'+ cfg['scorer']+".h5"), key='df_with_missing', mode='w')
                frame.to_csv(fn)
        except FileNotFoundError:
            print("Attention:", folder, "does not appear to have labeled data!")

def analyze_videos_converth5_to_csv(videopath,videotype='.avi'):
    """
    By default the output poses (when running analyze_videos) are stored as MultiIndex Pandas Array, which contains the name of the network, body part name, (x, y) label position \n
    in pixels, and the likelihood for each frame per body part. These arrays are stored in an efficient Hierarchical Data Format (HDF) \n
    in the same directory, where the video is stored. If the flag save_as_csv is set to True, the data is also exported as comma-separated value file. However,
    if the flag was *not* set, then this function allows the conversion of all h5 files to csv files (without having to analyze the videos again)!
    
    This functions converts hdf (h5) files to the comma-separated values format (.csv), which in turn can be imported in many programs, such as MATLAB, R, Prism, etc.
    
    Parameters
    ----------
    
    videopath : string
        A strings containing the full paths to videos for analysis or a path to the directory where all the videos with same extension are stored.

    videotype: string, optional
        Checks for the extension of the video in case the input to the video is a directory.\nOnly videos with this extension are analyzed. The default is ``.avi``

    Examples
    --------

    Converts all pose-output files belonging to mp4 videos in the folder '/media/alex/experimentaldata/cheetahvideos' to csv files. 
    deeplabcut.analyze_videos_converth5_to_csv('/media/alex/experimentaldata/cheetahvideos','.mp4')  
 
    """
    start_path=os.getcwd()
    os.chdir(videopath)
    Videos=[fn for fn in os.listdir(os.curdir) if (videotype in fn) and ('_labeled.mp4' not in fn)] #exclude labeled-videos!
    
    Allh5files=[fn for fn in os.listdir(os.curdir) if (".h5" in fn) and ("resnet" in fn)]
    
    for video in Videos:
         vname = Path(video).stem
         #Is there a scorer for this?
         PutativeOutputFiles=[fn for fn in Allh5files if vname in fn]
         for pfn in PutativeOutputFiles:
             scorer=pfn.split(vname)[1].split('.h5')[0]
             if "DeepCut" in scorer:
                 DC = pd.read_hdf(pfn, 'df_with_missing')
                 print("Found output file for scorer:", scorer)
                 print("Converting to csv...")
                 DC.to_csv(pfn.split('.h5')[0]+'.csv')
    
    os.chdir(str(start_path))
    print("All pose files were converted.")

def pathmagic(string):
    parts=string.split('\\')
    if len(parts)==1:
        return string
    elif len(parts)==3: #this is the expected windows case, it will split into labeled-data, video, imgNR.png
        return os.path.join(*parts) #unpack arguments from list with splat operator
    else:
        return string

def convertpaths_to_unixstyle(Data,fn,cfg):
    ''' auxiliary function that converts paths in annotation files:
        labeled-data\\video\\imgXXX.png to labeled-data/video/imgXXX.png '''
    Data.to_csv(fn + "windows" + ".csv")
    Data.to_hdf(fn + "windows" + '.h5','df_with_missing',format='table', mode='w')

    imindex=[pathmagic(s) for s in Data.index]
    for j,bpt in enumerate(cfg['bodyparts']):
        index = pd.MultiIndex.from_product([[cfg['scorer']], [bpt], ['x', 'y']],names=['scorer', 'bodyparts', 'coords'])
        frame = pd.DataFrame(Data[cfg['scorer']][bpt].values, columns = index, index = imindex)
        if j==0:
            dataFrame=frame
        else:
            dataFrame = pd.concat([dataFrame, frame],axis=1)
    
    dataFrame.to_csv(fn + ".csv")
    dataFrame.to_hdf(fn + '.h5','df_with_missing',format='table', mode='w')
    return dataFrame

def merge_windowsannotationdataONlinuxsystem(cfg):
    ''' If a project was created on Windows (and labeled there,) but ran on unix then the data folders
    corresponding in the keys in cfg['video_sets'] are not found. This function gets them directly by 
    looping over all folders in labeled-data '''
    
    AnnotationData=None
    data_path = Path(cfg['project_path'],'labeled-data')
    annotationfolders=[fn for fn in os.listdir(data_path) if "_labeled" not in fn]
    print("The following folders were found:", annotationfolders)
    for folder in annotationfolders:
        try:
            data = pd.read_hdf(os.path.join(data_path , folder, 'CollectedData_'+cfg['scorer']+'.h5'),'df_with_missing')
            if AnnotationData is None:
                AnnotationData=data
            else:
                AnnotationData=pd.concat([AnnotationData, data])

        except FileNotFoundError:
            print(str(os.path.join(data_path , folder, 'CollectedData_'+cfg['scorer']+'.h5')), " not found (perhaps not annotated)")

    return AnnotationData

