#!/usr/bin/env python

import logging
import ATFUtils

#######################################################################
## ATFLog 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]
##
######################################################################
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 get_loglevel(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 set_summarylog(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.get_loglevel(loglevel)

    def set_detaillog(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.get_loglevel(loglevel)

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

        Parameters:
            loglevel: Log level for logging to STDOUT
        """
        
        self.StdoutLog['loglevel'] = self.get_loglevel(loglevel)
        self.StdoutLog['logstatus'] = 'true'    
    
    def create(self, logname='ATF_LOG'):
        """
        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
        atfrootdir = ATFUtils.get_environ('ATF_ROOT')
        abspath = atfrootdir + "/" + self.SummaryLog['filename']

        try:
            summary_handler = logging.FileHandler(abspath, mode='a')

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

        else:
            summary_handler.setLevel(self.SummaryLog['loglevel'])
            summary_formatter = logging.Formatter(self.SummaryLog['format'])
            summary_handler.setFormatter(summary_formatter)
            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['logstatus'] == '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

        ATFUtils.Logger = logger
        return 0

    def add_detaillog_handler(self, 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
        atfworkdir = ATFUtils.get_environ('ATF_WORKUNIT')
        abspath = atfworkdir + "/Log/" + 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")
            
        ATFUtils.Logger = logger
        return 0

    def remove_detaillog_handler(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