#! /usr/bin/env python
'''Import an existing set of configuration files.  If you can collect all
of the files into one place, you can import your entire configuration in a
single go.
'''

from __future__ import print_function

import sys
# pylint: disable=no-name-in-module
from bacula_tools import Director, Catalog, ID, DIRECTOR_ID, parser_support
import curses
import curses.wrapper
import pprint


if len(sys.argv) < 2:
    print("Usage: %s configfile.conf [configfile2.conf...]" % sys.argv[0])
    exit()

# pylint: disable=too-few-public-methods


class Writer(object):

    '''Convenience class for displaying the results of parsing the
    configuration files.

    '''

    def __init__(self, screen):
        '''Constructor.  Needs a curses screen object.
        '''
        self.screen = screen
        (_, self.restx) = screen.getmaxyx()
        self.restx = self.restx - 5
        self.rows = {}
        self.rows['empty'] = []
        curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
        curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK)
        self.normal = curses.color_pair(0)  # Have to start somewhere!
        self.problem = curses.color_pair(1)
        self.good = curses.color_pair(2)
        screen.erase()
        screen.box()
        screen.refresh()
        screen.nodelay(0)
        return

    def __call__(self, msg):
        '''Write a message to the screen.

        Since what we're displaying is a series of classes and the
        success/failure of each one, we need to figure out how many we've
        parsed, along with failures.  We also need to keep track of where
        on the screen we're drawing a particular class.  Because we do all
        of the book keeping in here, we're perfectly able to hande
        completely random ordering of result.
        '''
        (key, value) = msg.split(': ', 1)
        row = self.rows.setdefault(key, [len(self.rows) + 2, 0, 0, ''])
        row[3] = value.replace('\n', ' ')
        if 'Unable to handle' in value:
            row[2] += 1
            errorlog.append(value)
        else:
            row[1] += 1
        self.screen.addstr(row[0], 3, '%s: %d/' % (key, row[1]), self.normal)
        if row[2]:
            self.screen.addstr(str(row[2]), self.problem)
        else:
            self.screen.addstr('0', self.normal)
        (_, x) = self.screen.getyx()
        self.screen.addstr('  ' + row[3][:self.restx - x], self.normal)
        (_, x) = self.screen.getyx()
        self.screen.addstr(' ' * ((self.restx - x) - 2), self.normal)
        self.screen.refresh()
        return

    def finish(self):
        '''Print a completion message wait for a keypress.
        '''
        self.screen.addstr(0, 1,
                           'Finished processing, press any key to exit',
                           self.good)
        self.screen.getkey()

writer = None
errorlog = []


def main(stdscreen):
    '''Main entry poing for the program.
    '''
    global writer
    writer = Writer(stdscreen)
    for argument in sys.argv[1:]:
        try:
            stuff = parser_support.parser(open(argument).read(), writer)
        except:
            stuff = []
    director = None
    for director_object in stuff:
        if type(director_object) == Director:
            director = director_object
            break
    for catalog_object in stuff:
        if type(catalog_object) == Catalog:
            catalog_object.set(DIRECTOR_ID, director[ID])
    writer.finish()
    return

try:
    curses.wrapper(main)
except:
    pprint.pprint(writer.rows)
    raise

if errorlog:
    print("Encountered these errors")
    for err in errorlog:
        print(err)
