#!/usr/bin/env python

"""errorable:  Base class for classes with error state."""

import logging
import sys


class Errorable:
    def __init__(self):
        self._update_ui_fn = lambda: None
        self._last_error = None
        self._err_children = []

    def reset_error(self):
        self.last_error = None

    def get_last_error(self):
        errors = ""
        for child in self._err_children:
            if child.last_error is not None:
                if len(errors) > 0:
                    errors += ", %s" % child.last_error
                else:
                    errors += "%s" % child.last_error
        if self._last_error is not None:
            if len(errors) > 0:
                errors += ", %s" % self._last_error
            else:
                errors += "%s" % self._last_error
        if len(errors) == 0:
            return None
        else:
            return errors

    def set_last_error(self, error):
        self._last_error = error
        if error is None:
            for child in self._err_children:
                child.last_error = None

    last_error = property(get_last_error, set_last_error)

    def _report_error(self, error=None):
        if error is None:
            error_str = 'General error'
        else:
            error_str = str(error)

        self.last_error = error_str

        # (1) Get exception info (if any)
        t = sys.exc_info()[0]
        v = sys.exc_info()[1]

        # (2) Get calling stack frame
        try:
            caller = str(sys._getframe(1).f_code.co_name)

        except:
            caller = "Unknown"

        logging.error("Error in %s" % caller)
        logging.error(str(error))
        if t is not None:
            logging.error("Underlying: %s, %s" % (t, v))

        self._update_ui_fn()