# Note that the API of this module is guaranteed to change.

import argparse
import logging
import os
import sys
import shutil
import tempfile


class Context:

    def __init__(self):
        self._vars = {}

    def get(self, key, default=None):
        return self._vars.get(key, default)

    def __getitem__(self, key):
        return self._vars[key]

    def __setitem__(self, key, value):
        self._vars[key] = value


class Settingses:

    def __init__(self):
        self._scenarios = []

    def add_scenario(self, name):
        self._scenarios.append(name)

    def is_wanted_scenario(self, name):
        return (not self._scenarios or
                any(name.casefold() == w.casefold() for w in self._scenarios))


class Datadir:

    def __init__(self):
        self._dirname = None
        self._ours = False

    def get(self):
        if self._dirname is None:
            self._dirname = tempfile.mkdtemp()
            logging.info('Created temporary directory %s', self._dirname)
            self._ours = True
        return self._dirname

    def set(self, dirname):
        if dirname is not None:
            self._dirname = os.path.abspath(dirname)
            if not os.path.exists(self._dirname):
                os.mkdir(self._dirname)
            self._ours = False

    def cleanup(self):
        if self._ours:
            logging.debug('Removing %s', self._dirname)
            shutil.rmtree(self._dirname)


class Run:

    def __init__(self):
        self._name = None
        self._context = None
        self._srcdir = None
        self._settingses = Settingses()
        self._datadir = None
        self._tempdir = None
        self._parse_options()

    def _parse_options(self):
        p = argparse.ArgumentParser()
        p.add_argument('--log', default='/dev/null')
        p.add_argument('--tempdir')
        p.add_argument(
            '--scenario', '-s', action='append', dest='scenarios', default=[])
        args = p.parse_args()
        self._setup_logging(args.log)
        self._tempdir = args.tempdir
        for s in args.scenarios:
            self._settingses.add_scenario(s)

    def _setup_logging(self, filename):
        format = '%(asctime)s %(levelname)s %(message)s'
        logging.basicConfig(
            filename=filename, format=format, level=logging.DEBUG)
        logging.info('test program starts =============')

    def get_context(self):
        return self._context

    def start(self, name):
        if not self._settingses.is_wanted_scenario(name):
            logging.info('Skipping unwanted scenario %s', name)
            return False

        logging.info('Start scenario %s', name)
        self._context = Context()
        self._name = name
        self._srcdir = os.getcwd()
        self._datadir = Datadir()
        self._datadir.set(self._tempdir)
        dirname = tempfile.mkdtemp(dir=self._datadir.get())
        os.chdir(dirname)
        return True

    def end(self):
        logging.info('OK %s', self._name)
        sys.stdout.write('OK: {}\n'.format(self._name))
        os.chdir(self._srcdir)
        self._datadir.cleanup()


def assertTrue(a):
    if not a:
        raise Exception(
            'expected {!r} to be true, but was disappointed'.format(a, b))


def assertEqual(a, b):
    if a != b:
        raise Exception(
            'expected {!r} == {!r}, but was disappointed'.format(a, b))


def assertNotEqual(a, b):
    if a == b:
        raise Exception(
            'expected {!r} != {!r}, but was disappointed'.format(a, b))