# -*- coding: utf-8 -*-
import agent_util
import logging
from glob import glob
from library.log_matcher import LogMatcher


class LinuxLogsPlugin(agent_util.Plugin):

    textkey = "linux_log"
    label = "Event log"

    @classmethod
    def get_metadata(self, config):
        data = {
            'count': {
                'label': 'Event entry count',
                'options': None,
                'status': agent_util.SUPPORTED,
                'error_message': None,
                'unit': 'count',
                'option_string': True
            }
        }
        return data

    def check(self, textkey, data, config={}):
        # Passed data from the check schedule
        log_source = data.get('log_source')
        timescale = data.get('timescale')
        expression = data.get('filter')
        log_source = log_source.strip(' ')

        if '*' in log_source or '?' in log_source:
            # Handle multiple files
            files = glob(log_source)
        else:
            files = [log_source]

        file_inodes = {}
        total_metrics = 0

        expression = expression or "*"
        expression = expression.replace('*', '.*')
        expression = expression.replace('""', '.*')
        for target in files:
            # Extract the file current inode
            try:
                file_inodes[target] = LogMatcher.get_file_inode(target)
            except OSError:
                import sys
                _, error, _ = sys.exc_info()
                logging.error("Error opening %s file." % (target))
                logging.error(error)
                continue

            # Extract data from the agent cache about the check
            log_data = self.get_cache_results(
                textkey,
                "%s/%s" % (self.schedule.id, target)
            )
            if log_data:
                log_data = log_data[0][-1]
            else:
                log_data = dict()

            last_line_number = log_data.get('last_known_line')
            stored_inode = log_data.get('inode')
            results = log_data.get('results', [])

            # Extract the lines of the file.
            try:
                total_lines, current_lines = LogMatcher.get_file_lines(
                    last_line_number, target, file_inodes[target], stored_inode)
            except IOError:
                import sys
                _, e, _ = sys.exc_info()
                logging.error("Could not open file: %s" % str(e))
                return None

            logging.info("Stored line %s Current line %s Looking at %s lines" % (
                str(last_line_number), str(total_lines), str(len(current_lines))
            ))
            # Perform the matching of the expression in the lines
            log_matcher = LogMatcher(stored_inode)
            results = log_matcher.match(current_lines, expression)
            metric, results = log_matcher.calculate_metric(results, timescale)
            total_metrics += metric and metric or 0

            cache_data = dict(
                inode=file_inodes[target],
                last_known_line=total_lines,
                results=results
            )
            self.cache_result(
                textkey,
                "%s/%s" % (self.schedule.id, target),
                cache_data
            )
            logging.info('Found %s instances of "%s" in %s' % (
                str(metric or 0), expression, target)
            )
        return total_metrics