# Copyright (C) 2010  Leonard Thomas
#
# This file is part of Dodai.
#
# Dodai is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Dodai is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.


import logging
import logging.handlers
import os

class ConfigLog(object):

    LEVELS = {
        logging.CRITICAL: [
            'critical',
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            "%(message)s"],
        logging.ERROR: [
            'error',
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            "%(message)s"],
        logging.WARNING: [
            'warning',
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            "%(message)s"],
        logging.INFO: [
            'info',
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            "%(message)s"],
        logging.DEBUG: [
            'debug',
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            "%(message)s"]
    }

    MAX_BYTES = 10485760
    BACKUP_COUNT = 5
    FILE_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    STDOUT_FORMAT = "%(message)s"

    def __init__(self):
        self.log_level = logging.CRITICAL
        self.directory = None
        self._levels = {}

    def set_log_level(self, level):
        try:
            level = self._fetch_log_level(level)
        except InvalidLevelException:
            pass
        else:
            self.log_level = level

    def set_directory(self, directory):
        if os.path.isdir(directory):
            self.directory = directory
        else:
            raise NoDirectoryExistException(directory)

    def get_file_message_format(self, level):
        if not self._levels:
            self._levels = self.LEVELS
        level = self._fetch_log_level(level)
        return self._levels[level][1]

    def get_screen_message_format(self, level):
        if not self._levels:
            self._levels = self.LEVELS
        level = self._fetch_log_level(level)
        return self._levels[level][2]

    def _fetch_log_level(self, level):
        out = None
        if isinstance(level, str):
            level = level.strip().lower()
        if level in self.LEVELS:
            out = level
        else:
            for key, items in self.LEVELS.items():
                if level == items[0]:
                    out = key
        if not out:
            raise InvalidLevelException(level)
        else:
            return out

    def _build_filepath(self, data):
        data = os.path.normpath(data)
        if data.startswith(os.path.sep):
            dir = os.path.dirname(data)
            if not os.path.isdir(dir):
                raise NoDirectoryExistException(dir)
        else:
            if not self.directory:
                raise DirectoryNotSetException()
            else:
                data = os.path.join(self.directory, data)
        return data

    def load(self, name):
        log =logging.getLogger(name)
        log.setLevel(self.log_level)
        return log

    def attach_file_handler(self, log, filename):
        filepath = self._build_filepath(filename)
        handler = logging.handlers.RotatingFileHandler(
                filepath, maxBytes = self.MAX_BYTES,
                backupCount=self.BACKUP_COUNT)
        file_format = self.get_file_message_format(self.log_level)
        format_obj = logging.Formatter(file_format)
        handler.setFormatter(format_obj)
        handler.setLevel(self.log_level)
        log.addHandler(handler)

    def attach_screen_handler(self, log, level=None):
        if level:
            level = self._fetch_log_level(level)
        else:
            level = self.log_level
        message_format = self.get_screen_message_format(level)
        handler = logging.StreamHandler()
        handler.setLevel(level)
        format_obj = logging.Formatter(message_format)
        handler.setFormatter(format_obj)
        log.addHandler(handler)


class NoDirectoryExistException(Exception):
    pass


class DirectoryNotSetException(Exception):
    pass


class InvalidLevelException(Exception):
    pass