"""
 logger class contains variables and methods for Logging 
 the events during the test run.

 Variables:
      SummaryLog: [filename, loglevel, format]

      DetailLog: [filename, loglevel, format]

      StdoutLog: [loglevel, format]

"""
import logging

class Log():

    def __init__(self):
        self._summarylog = {'format':
                '%(asctime)s %(levelname)s  : %(filename)s %(lineno)d  - \
                \'%(message)s\''}
        self._detaillog = {'format': 
                '%(asctime)s %(levelname)s  : %(pathname)s %(funcName)s \
                %(lineno)d - \'%(message)s\''}
        self._stdoutlog = {'logstatus':'false', 'format':'%(asctime)s \
                %(levelname)s : %(filename)s %(lineno)d - \'%(message)s\''}
        self._loggers = []


    def getLogLevel(self, loglevel):
        """
        Description:
            Returns logging.(LogLevel)  for loglevel

        Parameters:
            loglevel: String specifying the loglevel

        Returns:
            logging.(Loglevel) 
        """

        LEVELS = {'DEBUG': logging.DEBUG,
                  'INFO': logging.INFO,
                  'WARNING': logging.WARNING,
                  'ERROR': logging.ERROR,
                  'CRITICAL': logging.CRITICAL,
                  'debug': logging.DEBUG,
                  'info': logging.INFO,
                  'warning': logging.WARNING,
                  'error': logging.ERROR,
                  'critical': logging.CRITICAL}
        return LEVELS.get(loglevel, logging.NOTSET)
        
    def setSummaryLog(self, filename='SummaryLog.out', loglevel='INFO'):
        """
        Description:
            Set Summary Log Name and Log Level

        Parameters:
            filename: SummaryLog File Name
            loglevel : Log level to be set for summary log
        """

        self._summarylog['filename'] = filename
        self._summarylog['loglevel'] = self.getLogLevel(loglevel)

    def setDetailLog(self, filename='DetailLog.out', loglevel = 'DEBUG'):
        """
        Description:
            Set Detail Log Name and Log Level

        Parameters:
            filename: DetailLog FIle name
            loglevel: Log level to be set for detail log
        """
        
        self._detaillog['filename'] = filename
        self._detaillog['loglevel'] = self.getLogLevel(loglevel)

    def setStdoutLog(self, do_log=True, loglevel='INFO'):
        """
        Description:
            Set Log Level for  logging to STDOUT

        Parameters:
            loglevel: Log level for logging to STDOUT
        """
        self._stdoutlog['do_log'] = do_log
        self._stdoutlog['loglevel'] = self.getLogLevel(loglevel)
    
    def createLogger(self, atfdir, logname='ATFLOG'):
        """
        Description:
            Create a Logger with LogName 'logname'
            
        Parameters:
            logname: Name of the Logger

        Return:
            Success: 0 (Successful creation of logger with name : 'logname')
            Failure: 1 (Unable to create logger with name: logname)
        """

        # Create a Logger Object with name "logname".
        # Set the log level to 'DEBUG'
        logger = logging.getLogger(logname)
        logger.setLevel(logging.DEBUG)
        self.loggers.append({'logname': logname})

        # Create Summary Log File Handler
        # Set the Log Level
        # Set the Log Record format for Summary Log
        summarylog_abspath = atfdir + "/" + self._summarylog['filename']
        try:
            summary_handler = logging.FileHandler(summarylog_abspath, mode='w')

        except IOError as (errno, errstr):
            print "I/0 error({0}): {1}".format(errno, errstr)
            return 1

        else:
            summary_formatter = logging.Formatter(self._summarylog['format'])
            summary_handler.setFormatter(summary_formatter)
            summary_handler.setLevel(self._summarylog['loglevel'])
            logger.addHandler(summary_handler)
            for log in self._loggers:
                if log['logname'] == logname:
                    log['summary_handler'] = summary_handler
                    break
                
        # Create Stdout Log StreamHandler if log to stdout is defined
        # Set the Log Level
        # Set the Log Record format for STDOUT
        if self._stdoutlog['do_log'] == 'true':
            stdout_handler = logging.StreamHandler()
            stdout_handler.setLevel(self._stdoutlog['loglevel'])
            stdout_formatter = logging.Formatter(self._stdoutlog['format'])
            stdout_handler.setFormatter(stdout_formatter)
            logger.addHandler(stdout_handler)
            for log in self._loggers:
                if log['logname'] == logname:
                    log['stdout_handler'] = stdout_handler
                    break
        return 0

    def addDetaillogHandler(self, abspath, logname):
        """
        Description:
            Add a Detail Log FileHandler to Logger with logname 'logname'

        Parameters:
            logname: Name of the Logger

        Returns:
            Success: 0
            Failure: 1
        """

        logger = logging.getLogger(logname)

        # Create Detail Log File Handler
        # Set the Log Level
        # Set the Log Record format for Detail Log
        abspath = abspath + self._detaillog['filename']

        try:
            detail_handler = logging.FileHandler(abspath, mode='w')

        except IOError as (errno, errstr):
            logger.error("IOError ({0}): {1}".format(errno, errstr))
            return 1

        else:
            detail_handler.setLevel(self._detaillog['loglevel'])
            detail_formatter = logging.Formatter(self._detaillog['format'])
            detail_handler.setFormatter(detail_formatter)
            logger.addHandler(detail_handler)
            
            for log in self._loggers:
                if log['logname'] == logname:
                    log['detail_handler'] = detail_handler
                    break

        logger.debug("Detail Log File Handler Successfully Added")
            
        return 0

    def removeDetaillogHandler(self, logname):
        """
        Description:
            Remove Detail Log File Handler from Logger with 
            logname 'logname'

        Parameters:
            logname: Name of the Logger
        """

        logger = logging.getLogger(logname)
        Map = {}
        for log in self._loggers:
            Map = log
        
            if Map.has_key('detail_handler'):
                detail_handler = log.pop('detail_handler')
                logger.removeHandler(detail_handler)              
                logger.info("DetailLog Handler Removed for the Logger: " +
                        logname)        
            else:
                logger.warning("DetailLog Handler Not Found for the Logger: " +
                        logname)
        return