from enum import Enum

from core.concept import Concept


class BuiltinConcepts(Enum):
    """
    List of builtin concepts that do no need any specific implementation
    """
    SHEERKA = 1
    SUCCESS = 2
    ERROR = 3
    UNKNOWN_CONCEPT = 4  # the request concept is not recognized
    RETURN_VALUE = 5  # a value is returned
    CONCEPT_TOO_LONG = 6  # concept cannot be processed by exactConcept parser
    NEW_CONCEPT = 7  # when a new concept is added
    UNKNOWN_PROPERTY = 8  # when requesting for a unknown property
    PARSER_RESULT = 9
    TOO_MANY_SUCCESS = 10  # when expecting a limited number of successful return value
    TOO_MANY_ERRORS = 11  # when expecting a limited number of successful return value
    NOT_FOR_ME = 12  # a parser recognize that the entry is not meant for it
    IS_EMPTY = 13  # when a set is empty
    INVALID_RETURN_VALUE = 14  # the return value of an evaluator is not correct
    BEFORE_PARSING = 15  # activated before evaluation by the parsers
    PARSING = 16  # activated during the parsing. It contains the text to parse
    AFTER_PARSING = 17  # after parsing
    BEFORE_EVALUATION = 18  # before evaluation
    EVALUATION = 19  # activated when the parsing process seems to be finished
    AFTER_EVALUATION = 20  # activated when the parsing process seems to be finished
    CONCEPT_ALREADY_DEFINED = 21  # when you try to add the same concept twice
    NOP = 22  # no operation concept. Does nothing
    PROPERTY_EVAL_ERROR = 23  # cannot evaluate a property of a concept
    ENUMERATION = 24  # represents a list or a set


"""
Some concepts have a specific implementation
It's mainly to a have proper __repr__ implementation, or redefine the is_unique attribut
"""


class SuccessConcept(Concept):
    def __init__(self):
        super().__init__(BuiltinConcepts.SUCCESS, True, True, BuiltinConcepts.SUCCESS)


class ErrorConcept(Concept):
    def __init__(self, error=None):
        super().__init__(BuiltinConcepts.ERROR, True, False, BuiltinConcepts.ERROR, body=error)

    def __repr__(self):
        return f"({self.id}){self.name}: {self.body}"


class ReturnValueConcept(Concept):
    """
    This class represents the result of a data flow processing
    It's the main input for the evaluators
    """

    def __init__(self, who=None, status=None, value=None, message=None, parents=None):
        super().__init__(BuiltinConcepts.RETURN_VALUE, True, False, BuiltinConcepts.RETURN_VALUE)
        self.set_prop("who", who)
        self.set_prop("status", status)
        self.body = value
        self.set_prop("message", message)
        self.set_prop("parents", parents)

    @property
    def who(self):
        return self.props["who"].value

    @who.setter
    def who(self, value):
        self.set_prop("who", value)

    @property
    def status(self):
        return self.props["status"].value

    @status.setter
    def status(self, value):
        self.set_prop("status", value)

    @property
    def value(self):
        return self.body

    @value.setter
    def value(self, value):
        self.body = value

    @property
    def message(self):
        return self.props["message"].value

    @message.setter
    def message(self, value):
        self.set_prop("message", value)

    @property
    def parents(self):
        return self.props["parents"].value

    @parents.setter
    def parents(self, value):
        self.set_prop("parents", value)

    def __repr__(self):
        return f"ReturnValue(who={self.who}, status={self.status}, value={self.value}, message={self.message})"

    def __eq__(self, other):
        if not isinstance(other, ReturnValueConcept):
            return False

        return self.who == other.who and \
               self.status == other.status and \
               self.value == other.value and \
               self.message == other.message

    def __hash__(self):
        return hash((self.who, self.status, self.value))


class UnknownPropertyConcept(Concept):
    """
    This error is raised when, during sheerka.new(), an unknown property is asked
    """

    def __init__(self, property_name=None, concept=None):
        super().__init__(BuiltinConcepts.UNKNOWN_PROPERTY, True, False, BuiltinConcepts.UNKNOWN_PROPERTY)
        self.set_prop("concept", concept)
        self.body = property_name

    def __repr__(self):
        return f"UnknownProperty(property={self.property_name}, concept={self.concept})"

    @property
    def concept(self):
        return self.props["concept"].value

    @property
    def property_name(self):
        return self.body


class ParserResultConcept(Concept):
    """
    Result of a parsing
    """

    def __init__(self, parser=None, source=None, value=None, try_parsed=None):
        super().__init__(BuiltinConcepts.PARSER_RESULT, True, False, BuiltinConcepts.PARSER_RESULT)
        self.set_prop("parser", parser)
        self.set_prop("source", source)
        self.set_prop("try_parsed", try_parsed)  # in case of error, what was found before the error
        self.body = value

    def __repr__(self):
        return f"ParserResult({self.body})"

    def __eq__(self, other):
        if not isinstance(other, ParserResultConcept):
            return False

        return self.source == other.source and \
               self.parser == other.parser and \
               self.body == other.body and \
               self.try_parsed == other.try_parsed

    @property
    def value(self):
        return self.body

    @property
    def try_parsed(self):
        return self.props["try_parsed"].value

    @property
    def source(self):
        return self.props["source"].value

    @property
    def parser(self):
        return self.props["parser"].value


class InvalidReturnValueConcept(Concept):
    """
    Error returned when an evaluator is not correctly coded
    The accepted return value are
        ReturnValueConcept, list of ReturnValueConcept or None
    """

    def __init__(self, return_value=None, evaluator=None):
        super().__init__(BuiltinConcepts.INVALID_RETURN_VALUE, True, False, BuiltinConcepts.INVALID_RETURN_VALUE)
        self.set_prop("evaluator", evaluator)
        self.body = return_value


class BeforeParsingConcept(Concept):
    def __init__(self):
        super().__init__(BuiltinConcepts.BEFORE_PARSING, True, True, BuiltinConcepts.BEFORE_PARSING)


class EvaluationConcept(Concept):
    def __init__(self):
        super().__init__(BuiltinConcepts.EVALUATION, True, True, BuiltinConcepts.EVALUATION)


class AfterEvaluationConcept(Concept):
    def __init__(self):
        super().__init__(BuiltinConcepts.AFTER_EVALUATION, True, True, BuiltinConcepts.AFTER_EVALUATION)


class PropertyEvalError(Concept):
    def __init__(self, property_name=None, concept=None, error=None):
        super().__init__(BuiltinConcepts.PROPERTY_EVAL_ERROR, True, False, BuiltinConcepts.PROPERTY_EVAL_ERROR)
        self.set_prop("concept", concept)
        self.set_prop("error", error)
        self.body = property_name

    def __repr__(self):
        return f"PropertyEvalError(property={self.property_name}, concept={self.concept}), error={self.error})"

    @property
    def concept(self):
        return self.props["concept"].value

    @property
    def error(self):
        return self.props["error"].value

    @property
    def property_name(self):
        return self.body