#
#   config.py
#
#   Default config values and basic wrapper for PyYaml. New config options
#   should be added to the dictionary below, along with appropriate defaults.
#

import yaml
import types
import os
from pkg_resources import Requirement, resource_filename
from types import SimpleNamespace

import logparse
import logging
logger = logging.getLogger(__name__)

def locate(filename):
    logger.debug("Searching for {0}".format(filename))
    loc = resource_filename(Requirement.parse(__package__), filename)
    logger.debug("Found {0}".format(loc))
    return loc

class Configuration(dict):

    def __init__(self, *arg, **kw):
        super(Configuration, self).__init__(*arg, **kw)
    
    def _str2bool(x):
        positives = ["yes", "true", "1", "y"]
        negatives = ["no", "false", "0", "n"]
        x = x.lower()
        if x in positives:
            return True
        elif x in negatives:
            return False
        else:
            raise ValueError("Unknown option %s" % x)

defaults = Configuration({
    'output': '',
    'header':  '/etc/logparse/header.html',
    'css': '/etc/logparse/main.css',
    'linewidth': 80,
    'embed-styles': False,
    'plain': False,
    'overwrite': False,
    'title': logparse.__name__,
    'maxlist': 10,
    'maxcmd': 3,
    'resolve-domains': 'fqdn',
    'mail': {
        'to': '',
        'from': '',
        'subject': 'logparse from $hostname$',
        'mailbin': '/usr/bin/mail',
    },
    'rotate': 'n',
    'verbose': 'n',
    'hddtemp': {
        'drives': ['/dev/sda'],
        'host': '127.0.0.1',
        'separator': '|',
        'timeout': 10,
        'port': 7634,
        'show-model': False, 
    },
    'apache': {
        'resolve-domains': '',
    },
    'sshd': {
        'resolve-domains': '',
    },
    'smbd': {
        'resolve-domains': '',
    },
    'httpd': {
        'resolve-domains': '',
    },
    'du': {
        'paths': ['/', '/etc', '/home'],
        'force-write': 'n',
    },
    'hostname-path': '/etc/hostname',
    'parsers': {},
    'ignore-parsers': {},
    'logs': {
        'auth': '/var/log/auth.log',
        'cron': '/var/log/cron.log',
        'sys': '/var/log/syslog',
        'smb': '/var/log/samba',
        'zfs': '/var/log/zpool.log',
        'alloc': '/var/log/du.log',
        'postfix': '/var/log/mail.log',
        'httpd': '/var/log/apache2'
    }
})

def verify(raw_dict, defaults):
    for key, value in raw_dict.items():
        if key in defaults: # valid key
            logger.debug("Found valid key {0} with value {1}".format(key, value))
            if (isinstance(value, dict)):
                verify(value, defaults[key])   # recurse nested dictionaries

        else:               # invalid key
            logger.warning("Invalid key {0} with value {1}".format(key, value))

def loadconf(argparser, configfile = "/etc/logparse/logparse.conf"):
    logger.debug("Getting config from {0}".format(configfile))
    try:
        raw_dict = yaml.safe_load(open(configfile))
        # verify fields
        verify(raw_dict, defaults)
        prefs = defaults
        for value in raw_dict:
            if(isinstance(raw_dict[value], dict)):
                for key in raw_dict[value].items():
                    logger.debug("Inserting key {0} with value {1}".format(key[0], key[1]))
                    if not value in prefs:
                        prefs[value] = {}
                    prefs[value][key[0]] = key[1]
            else:
                prefs[value] = raw_dict[value]
        if argparser.parse_args().to is not None:
            prefs['mail']['to'] = argparser.parse_args().to
        if not prefs['mail']['to']:
            logger.info("No recipient address provided, outputting to stdout")
        else:
            logger.info("Email will be sent to " + prefs['mail']['to'])
        return prefs 
    except Exception as e:
        logger.warning("Error processing config: " + str(e))