from startup import get_context
import ch.psi.utils.SciCat as SciCat
import java.lang.Boolean

def _sm():
    return get_context().sessionManager


def session_start(name, metadata=None):
    """ Starts new session. If a session os open, completes it first.

    Args:
         name(str): Session name.
         metadata(dict): Map of initial metdata parameters
                         If None(Default) use the default metadata definition. 

    Returns:
        session id (int)     
    """
    return _sm().start(name, metadata)

def session_stop():
    """ Stops current session, if open.         
    """
    return _sm().stop()

def session_pause():
    """ Pauses current session, if open.         
    """
    return _sm().pause()    

def session_resume():
    """ Resumes current session, if paused.         
    """
    return _sm().resume()    

def session_cancel():
    """ Cancels current session, if started and empty (no generated data).      
    """
    return _sm().cancel()        


def session_id():
    """ Returns current session id (0 if no session is started).

    Returns:
        session id (int)       
    """
    return _sm().getCurrentId()


def session_name():
    """ Returns current session name ("unknown" if no session is started) 

    Returns:
        session name(str)       
    """
    return _sm().getCurrentName()

def session_started():
    """ Returns true if a session is started.

    Returns:
        bool       
    """
    return _sm().isStarted()
            
def session_paused():
    """ Returns true if current session is paused.

    Returns:
        bool    
    """
    return _sm().isPaused()

        
def session_add_file(path):
    """ Adds additional file to session, if opened. 

    Args:
         path(str): Relative to data path or absolute.
    """
    return _sm().addAdditionalFile(path)


def session_ids():
    """ Returns list of completed sessions.

    Returns:
        list of int        
    """
    return _sm().getIDs()

def session_get_name(id=None):
    """ Return the name of a session.

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        session name (str)         
    """
    return _sm().getName() if id is None else _sm().getName(id)


def session_get_state(id=None):
    """ Returns the session state 

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        session state (str)    
    """
    return _sm().getState() if id is None else _sm().getState(id)  

def session_get_start(id=None):
    """ Returns the start timestamp of a session.

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        long  
    """
    return _sm().getStart() if id is None else _sm().getStart(id)

def session_get_stop(id):
    """ Returns the stop timestamp of a completed session.

    Args:
         id(int): Session id. 
    Returns:
        Timestamp (long)         
    """
    return _sm().getStop(id)    

def session_get_root(id=None):
    """ Returns the root data path of a session.

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        str
    """
    return _sm().getRoot() if id is None else _sm().getRoot(id)    


def session_get_info(id=None):
    """ Returns the session information.

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        session info (dict)    
    """
    return _sm().getInfo() if id is None else _sm().getInfo(id)  


def session_get_metadata(id=None):
    """ Returns a session info metadata.

    Args:
         id(int): Session id. Default (None) is the current session.

    Returns:
        session metadata (dict)    
    """
    return _sm().getMetadata() if id is None else _sm().getMetadata(id)  


def session_set_metadata(key, value,id=None):
    """ Set session  metadata entry.

    Args:
         key(str): Metadata key
         value(obj): Metadata value
         id(int): Session id. Default (None) is the current session.
    """
    return _sm().setMetadata(key, value) if id is None else _sm().setMetadata(id,key, value)  

    
def session_get_metadata_keys():
    """ Return the default metadata definition for samples.
    
    Returns:
        list of map entries       
    """
    return [str(e.key) for e in _sm().getMetadataDefinition()]


def session_get_metadata_type(key):
    """ Return the metadata type for a given key:
        String, Integer, Double, Boolean, List or Map.
    Args:
         key(str): Metadata key.

    Returns:
        str         
    """
    return str(_sm().getMetadataType(key))
       
def session_get_metadata_default(key):
    """ Return the metadata default value for a given key.
        
    Args:
         key(str): Metadata key.

    Returns:
         Object    
    """
    return _sm().getMetadataDefault(key)

def session_get_runs(id=None, relative=True):
    """ Return the runs of a session.

    Args:
         id(int): Session id. Default (None) is the current session.
         relative(bool): if True use relative file names (for files under the data root path)

    Returns:
        List of dicts     
    """
    return _sm().getRuns(java.lang.Boolean(relative)) if id is None else _sm().getRuns(id, relative)


def session_set_run_enabled(enabled, id=None, index=-1):
    """ Enable or disable a run.
        
    Args:
        enabled(bool): true for enabling, false for disabling
        id(int): Session id. Default (None) is the current session.
        index: Index of the run. Default (-1) for the last run.

    Returns:
         Object    
    """
    return _sm().setRunEnabled(index, enabled) if id is None else  _sm().setRunEnabled(id, index, enabled)

def session_get_additional_files(id=None, relative=True):
    """ Return additional files of a session.

    Args:
         id(int): Session id. Default (None) is the current session.
         relative(bool): if True use relative file names (for files under the data root path)

    Returns:
        List of str     
    """
    return _sm().getAdditionalFiles(java.lang.Boolean(relative)) if id is None else _sm().getAdditionalFiles(id, relative)

def session_get_file_list(id=None, relative=True):
    """ Return complete list of data files of a session.

    Args:
         id(int): Session id. Default (None) is the current session.
         relative(bool): if True use relative file names (for files under the data root path)

    Returns:
        List of str     
    """
    return _sm().getFileList(java.lang.Boolean(relative)) if id is None else _sm().getFileList(id, relative)

def session_create_zip(file_name, id=None, preserve_folder_structure=True):
    """ Create ZIP file with session contents

    Args:
        file_name(str): name of the zip file
        id(int): Session id. Default (None) is the current session.
        preserve_folder_structure: if False all data files are added to the root of the file.
                                   if True the folder structure under data root is preserved.
    """
    return _sm().createZipFile(file_name, preserve_folder_structure) if id is None else _sm().createZipFile(id, file_name, preserve_folder_structure)


def ingest_scicat(id, matadata={}, parameters=None):
    """ Ingest a completed session to SciCat
    
    Args:
        id(int): Session id. 
        creation_location_name(str):  
        
    Returns:
        Dataset ID in case of success. Otherwise throws an exception.               
    """
    sciCat= SciCat()
    result  = sciCat.ingest(id, matadata, parameters);
    print result.output
    if not result.success:
        raise  Exception ("Error ingesting session " + str(id))
    return result.datasetId