# -*- coding: utf8 -*-
"""
High-level Python bindings build on top of the low-level C API (clinkgrammar)
See http://www.abisource.com/projects/link-grammar/api/index.html to get
more information about C API.
"""

try:
    #pylint: disable=no-name-in-module
    import linkgrammar.clinkgrammar as clg
except ImportError:
    #pylint: disable=import-error
    import clinkgrammar as clg

Clinkgrammar = clg
__all__ = ['ParseOptions', 'Dictionary', 'Link', 'Linkage', 'Sentence',
           'LG_Error', 'LG_DictionaryError', 'LG_TimerExhausted', 'Clinkgrammar']

# A decorator to ensure keyword-only arguments to __init__ (besides self).
# In Python3 it can be done by using "*" as the second __init__ argument,
# but here it is done with a decorator so it will work also in Python2.
def kwargs_only(init):
    def new_init(self_, *args, **kwargs):
        if args:
            raise TypeError("{}: Positional arguments are "
                            "not allowed".format(self_.__class__.__name__))
        return init(self_, **kwargs)
    return new_init

class ParseOptions(object):
    @kwargs_only
    def __init__(self, verbosity=0,
                 linkage_limit=100,
                 min_null_count=0,
                 max_null_count=0,
                 islands_ok=False,
                 short_length=16,
                 all_short_connectors=False,
                 display_morphology=True,
                 spell_guess=False,
                 use_sat=False,
                 max_parse_time=-1,
                 disjunct_cost=None,
                 repeatable_rand=True,
                 test='',
                 debug='',
                 dialect='',
                 ):

        self._obj = clg.parse_options_create()
        self.verbosity = verbosity
        self.linkage_limit = linkage_limit
        self.min_null_count = min_null_count
        self.max_null_count = max_null_count
        self.islands_ok = islands_ok
        self.short_length = short_length
        self.all_short_connectors = all_short_connectors
        self.display_morphology = display_morphology
        self.spell_guess = spell_guess
        self.use_sat = use_sat
        self.max_parse_time = max_parse_time
        if disjunct_cost is not None:
            self.disjunct_cost = disjunct_cost
        self.repeatable_rand = repeatable_rand
        self.test = test
        self.debug = debug
        self.dialect = dialect

    # Allow only the attribute names listed below.
    def __setattr__(self, name, value):
        if not hasattr(self, name) and name != "_obj":
            # TypeError for consistency. It maybe should have been NameError.
            raise TypeError('Unknown parse option "{}".'.format(name))
        super(ParseOptions, self).__setattr__(name, value)

    @property
    def test(self):
        return clg.parse_options_get_test(self._obj)

    @test.setter
    def test(self, value):
        if not isinstance(value, str):
            raise TypeError("test must be set to a string")
        return clg.parse_options_set_test(self._obj, value)

    @property
    def debug(self):
        return clg.parse_options_get_debug(self._obj)

    @debug.setter
    def debug(self, value):
        if not isinstance(value, str):
            raise TypeError("debug must be set to a string")
        return clg.parse_options_set_debug(self._obj, value)

    @property
    def dialect(self):
        return clg.parse_options_get_dialect(self._obj)

    @dialect.setter
    def dialect(self, value):
        if not isinstance(value, str):
            raise TypeError("dialect must be set to a string")
        return clg.parse_options_set_dialect(self._obj, value)

    @property
    def verbosity(self):
        """
        This is the level of description printed to stderr/stdout about the
        parsing process.
        """
        return clg.parse_options_get_verbosity(self._obj)

    @verbosity.setter
    def verbosity(self, value):
        if not isinstance(value, int):
            raise TypeError("verbosity must be set to a nonnegative integer")
        if value < 0:
            raise ValueError("verbosity must be set to a nonnegative integer")
        clg.parse_options_set_verbosity(self._obj, value)

    @property
    def linkage_limit(self):
        """
        This parameter determines the maximum number of linkages that are
        considered in post-processing. If more than linkage_limit linkages
        found, then a random sample of linkage_limit is chosen for
        post-processing. When this happen a warning is displayed at verbosity
        levels bigger than 1.
        """
        return clg.parse_options_get_linkage_limit(self._obj)

    @linkage_limit.setter
    def linkage_limit(self, value):
        if not isinstance(value, int):
            raise TypeError("linkage_limit must be set to an integer")
        if value < 0:
            raise ValueError("linkage_limit must be positive")
        clg.parse_options_set_linkage_limit(self._obj, value)

    @property
    def disjunct_cost(self):
        """
        Determines the maximum disjunct cost used during parsing, where the
        cost of a disjunct is equal to the maximum cost of all of its connectors.
        The default is that only disjuncts of cost 2.7 or less are considered.
        """
        return clg.parse_options_get_disjunct_cost(self._obj)

    @disjunct_cost.setter
    def disjunct_cost(self, value):
        if not isinstance(value, float):
            raise TypeError("disjunct_cost must be set to a float")
        clg.parse_options_set_disjunct_cost(self._obj, value)

    @property
    def min_null_count(self):
        """
         The minimum number of null links that a parse might have. A call to
         sentence_parse will find all linkages having the minimum number of
         null links within the range specified by this parameter.
        """
        return clg.parse_options_get_min_null_count(self._obj)

    @min_null_count.setter
    def min_null_count(self, value):
        if not isinstance(value, int):
            raise TypeError("min_null_count must be set to an integer")
        if value < 0:
            raise ValueError("min_null_count must be positive")
        clg.parse_options_set_min_null_count(self._obj, value)

    @property
    def max_null_count(self):
        """
         The maximum number of null links that a parse might have. A call to
         sentence_parse will find all linkages having the minimum number of
         null links within the range specified by this parameter.
        """
        return clg.parse_options_get_max_null_count(self._obj)

    @max_null_count.setter
    def max_null_count(self, value):
        if not isinstance(value, int):
            raise TypeError("max_null_count must be set to an integer")
        if value < 0:
            raise ValueError("max_null_count must be positive")
        clg.parse_options_set_max_null_count(self._obj, value)

    @property
    def short_length(self):
        """
         The short_length parameter determines how long the links are allowed
         to be. The intended use of this is to speed up parsing by not
         considering very long links for most connectors, since they are very
         rarely used in a correct parse. An entry for UNLIMITED-CONNECTORS in
         the dictionary will specify which connectors are exempt from the
         length limit.
        """
        return clg.parse_options_get_short_length(self._obj)

    @short_length.setter
    def short_length(self, value):
        if not isinstance(value, int):
            raise TypeError("short_length must be set to an integer")
        if value < 0:
            raise ValueError("short_length must be positive")
        clg.parse_options_set_short_length(self._obj, value)

    @property
    def islands_ok(self):
        """
        This option determines whether or not "islands" of links are allowed.
        For example, the following linkage has an island:
            +------Wd-----+
            |     +--Dsu--+---Ss--+-Paf-+      +--Dsu--+---Ss--+--Pa-+
            |     |       |       |     |      |       |       |     |
          ///// this sentence.n is.v false.a this sentence.n is.v true.a
        """
        return clg.parse_options_get_islands_ok(self._obj) == 1

    @islands_ok.setter
    def islands_ok(self, value):
        if not isinstance(value, bool):
            raise TypeError("islands_ok must be set to a bool")
        clg.parse_options_set_islands_ok(self._obj, 1 if value else 0)

    @property
    def max_parse_time(self):
        """
         Determines the approximate maximum time (in seconds) that parsing is
         allowed to take. After this time has expired, the parsing process is
         artificially forced to complete quickly by pretending that no further
         solutions can be constructed. The actual parsing time might be
         slightly longer.
        """
        return clg.parse_options_get_max_parse_time(self._obj)

    @max_parse_time.setter
    def max_parse_time(self, value):
        if not isinstance(value, int):
            raise TypeError("max_parse_time must be set to an integer")
        clg.parse_options_set_max_parse_time(self._obj, value)

    @property
    def display_morphology(self):
        """
        Whether or not to show word morphology when a linkage diagram is printed.
        """
        return clg.parse_options_get_display_morphology(self._obj) == 1

    @display_morphology.setter
    def display_morphology(self, value):
        if not isinstance(value, bool):
            raise TypeError("display_morphology must be set to a bool")
        clg.parse_options_set_display_morphology(self._obj, 1 if value else 0)

    @property
    def spell_guess(self):
        """
         If greater then 0, the spelling guesser is used on unknown words.
         In that case, it performs at most this number of spell corrections
         per word, and performs run-on corrections which are not limited in
         their number. If 0 - the spelling guesser would not be used.
        """
        return clg.parse_options_get_spell_guess(self._obj)

    @spell_guess.setter
    def spell_guess(self, value):
        """
         If the value is an int, it is the maximum number of spell corrections
         per word. If it is True, an int value of 7 is assumed. A value of
         0 or False disables the spelling guesser.
         In case the spelling guesser is not disabled, run-on corrections will
         be issued too, not limited in their number.
        """
        if not isinstance(value, bool) and (not isinstance(value, int) or value < 0):
            raise TypeError("spell_guess must be set to bool or a non-negative integer")
        if isinstance(value, bool):
            value = 7 if value else 0
        clg.parse_options_set_spell_guess(self._obj, value)

    @property
    def use_sat(self):
        """
        To be used after enabling the use of the SAT solver in order to
        validate that it is supported by the LG library.
        """
        return clg.parse_options_get_use_sat_parser(self._obj)

    @use_sat.setter
    def use_sat(self, value):
        if not isinstance(value, bool):
            raise TypeError("use_sat must be set to a bool")
        clg.parse_options_set_use_sat_parser(self._obj, value)

    @property
    def all_short_connectors(self):
        """
         If true, then all connectors have length restrictions imposed on
         them -- they can be no farther than short_length apart. This is
         used when parsing in \"panic\" mode, for example.
        """
        return clg.parse_options_get_all_short_connectors(self._obj) == 1

    @all_short_connectors.setter
    def all_short_connectors(self, value):
        if not isinstance(value, bool):
            raise TypeError("all_short_connectors must be set to a bool")
        clg.parse_options_set_all_short_connectors(self._obj, 1 if value else 0)

    @property
    def repeatable_rand(self):
        """
        If set to True, then a repeatable random sequence will be used, whenever
        a random number is required.  The parser almost never uses random
        numbers; currently they are only used in one place: to sample a subset
        of linkages, if there are more parses than linkage_limit.
        """
        return clg.parse_options_get_repeatable_rand(self._obj) == 1

    @repeatable_rand.setter
    def repeatable_rand(self, value):
        if not isinstance(value, bool):
            raise TypeError("repeatable_rand must be set to a bool")
        clg.parse_options_set_repeatable_rand(self._obj, 1 if value else 0)


class LG_Error(Exception):
    @staticmethod
    def set_handler(ehandler_function, ehandler_data=None):
        old_handler = clg._py_error_set_handler((ehandler_function, ehandler_data))
        if isinstance(old_handler, str):
            return LG_Error._default_handler
        return old_handler

    # lg_error_formatmsg is implemented as method "formatmsg" on errinfo
    #@staticmethod
    #def format(lgerror):
    #    return clg.lg_error_formatmsg(lgerror)

    @staticmethod
    def flush():
        return clg.lg_error_flush()

    @staticmethod
    def printall(ehandler_func, ehandler_data=None):
        return clg._py_error_printall((ehandler_func, ehandler_data))

    @staticmethod
    def clearall():
        return clg.lg_error_clearall()

    @staticmethod
    def message(msg):
        """Print a message through the LG error facility"""
        # Propagate a possible ending "\n" into the format, from which the LG
        # error facility determine if this is a partial or a complete message.
        if msg[-1:] == "\n":      # a newline-ended complete message
            _local_eol = "\n"
            msg = msg[:-1]
        elif msg[-2:] == "\n\\":  # a newline-ended partial message
            _local_eol = ""
            msg = msg[:-1]
        else:
            _local_eol = ""       # a partial message

        return clg._prt_error('%s'+_local_eol, msg)

    @staticmethod
    def _default_handler(errinfo, data):
        # Exceptions (on data): TypeError, ValueError
        clg._py_error_default_handler(errinfo, data)

class LG_DictionaryError(LG_Error):
    pass

class Dictionary(object):
    def __init__(self, lang='en'):
        self._obj = clg.dictionary_create_lang(lang)
        if not self._obj:
            # We should get the error message from the library.
            raise LG_DictionaryError('Error: Failed to open dictionary {!r}'.format(lang))

    def __str__(self):
        return clg.dictionary_get_lang(self._obj)

    def __del__(self):
        if hasattr(self, '_obj'):
            clg.dictionary_delete(self._obj)
            del self._obj

    def __nonzero__(self):
        """Return False iff the dictionary could not be opened or has been closed"""
        if not hasattr(self, '_obj'):
            return False
        return bool(self._obj)

    __bool__ = __nonzero__      # Account python3

    def linkgrammar_get_dict_version(self):
        return clg.linkgrammar_get_dict_version(self._obj)

    def linkgrammar_get_dict_locale(self):
        return clg.linkgrammar_get_dict_locale(self._obj)


class Link(object):
    def __init__(self, linkage, index, left_word, left_label, right_label, right_word):
        self.linkage, self.index = linkage, index
        self.left_word, self.right_word, self.left_label, self.right_label = \
            left_word, right_word, left_label, right_label

    def __eq__(self, other):
        return self.left_word == other.left_word and self.left_label == other.left_label and \
            self.right_word == other.right_word and self.right_label == other.right_label

    def __str__(self):
        if self.left_label == self.right_label:
            return u"%s-%s-%s" % (self.left_word, self.left_label, self.right_word)
        else:
            return u"%s-%s-%s-%s" % (self.left_word, self.left_label, self.right_label, self.right_word)

    def __unicode__(self):
        return self.__str__()

    def __repr__(self):
        return u"Link: %s" % self.__str__()

    def __len__(self):
        return clg.linkage_get_link_length(self.linkage._obj, self.index)

    def num_domains(self):
        return clg.linkage_get_link_num_domains(self.linkage._obj, self.index)



class Linkage(object):

    def __init__(self, idx, sentence, parse_options):
        # Keep all args passed into clg.* functions.
        self.sentence, self.parse_options = sentence, parse_options
        self._obj = clg.linkage_create(idx, sentence._obj, parse_options)

    def __del__(self):
        if hasattr(self, '_obj'):
            clg.linkage_delete(self._obj)
            del self._obj

    def __nonzero__(self):
        """Return False for SAT sentinel value (NULL); else return True."""
        return bool(self._obj)

    __bool__ = __nonzero__      # Account python3

    def num_of_words(self):
        return clg.linkage_get_num_words(self._obj)

    def num_of_links(self):
        return clg.linkage_get_num_links(self._obj)

    def words(self):
        for i in range(self.num_of_words()):
            yield self.word(i)

    def word(self, i):
        return clg.linkage_get_word(self._obj, i)

    def unused_word_cost(self):
        return clg.linkage_unused_word_cost(self._obj)

    def link_cost(self):
        return clg.linkage_link_cost(self._obj)

    def disjunct_cost(self):
        return clg.linkage_disjunct_cost(self._obj)

    def link(self, i):
        return Link(self, i, self.word(clg.linkage_get_link_lword(self._obj, i)),
                    clg.linkage_get_link_llabel(self._obj, i),
                    clg.linkage_get_link_rlabel(self._obj, i),
                    self.word(clg.linkage_get_link_rword(self._obj, i)))

    def links(self):
        for i in range(self.num_of_links()):
            yield self.link(i)

    def violation_name(self):
        return clg.linkage_get_violation_name(self._obj)

    def diagram(self, display_walls=False, screen_width=180):
        return clg.linkage_print_diagram(self._obj, display_walls, screen_width)

    def postscript(self, display_walls=True, print_ps_header=False):
        return clg.linkage_print_postscript(self._obj, display_walls, print_ps_header)

    def constituent_tree(self, mode=1):
        return clg.linkage_print_constituent_tree(self._obj, mode)

    def word_byte_start(self, w):
        return clg.linkage_get_word_byte_start(self._obj, w)

    def word_byte_end(self, w):
        return clg.linkage_get_word_byte_end(self._obj, w)

    def word_char_start(self, w):
        return clg.linkage_get_word_char_start(self._obj, w)

    def word_char_end(self, w):
        return clg.linkage_get_word_char_end(self._obj, w)


class LG_TimerExhausted(LG_Error):
    pass


class Sentence(object):
    """
    sent = Sentence("This is a test.", Dictionary(), ParseOptions())
    # split() before parse() is optional.
    # split() has ParseOptions as an optional argument
    # (defaults to that of Sentence)
    if sent.split(ParseOptions(verbosity=2)) < 0:
        print "Cannot split sentence"
    else
        linkages = sent.parse()
        print "English: found ", sent.num_valid_linkages(), "linkages"
        for linkage in linkages:
            print linkage.diagram()
    """
    def __init__(self, text, lgdict, parse_options):
        # Keep all args passed into clg.* functions.
        self.text, self.dict, self.parse_options = text, lgdict, parse_options
        clg._py_incref(self.dict) # The Sentence struct refers to the Dictionary struct
        self._obj = clg.sentence_create(self.text, self.dict._obj)

    def __del__(self):
        if hasattr(self, '_obj'):
            clg.sentence_delete(self._obj)
            clg._py_decref(self.dict)
            del self._obj

    def split(self, parse_options=None):
        """Split a sentence. If an error occurs, return a negative number."""
        if not parse_options:
            parse_options = self.parse_options
        return clg.sentence_split(self._obj, parse_options._obj)

    def __len__(self):
        """The number of tokens in the sentence."""
        return clg.sentence_length(self._obj)

    def null_count(self):
        """Number of null links in the linkages of this sentence."""
        return clg.sentence_null_count(self._obj)

    class sentence_parse(object):
        def __init__(self, sent, parse_options):
            self.sent = sent
            self.num = 0
            self.parse_options = sent.parse_options if parse_options is None else parse_options
            self.rc = clg.sentence_parse(sent._obj, self.parse_options._obj)
            if clg.parse_options_timer_expired(self.parse_options._obj):
                raise LG_TimerExhausted()

        def __nonzero__(self):
            """Return False if there was a split or parse error; else return True."""
            return self.rc >= 0

        __bool__ = __nonzero__      # Account python3

        def __iter__(self):
            if 0 == clg.sentence_num_valid_linkages(self.sent._obj):
                return iter(())
            return self

        def __len__(self):
            return clg.sentence_num_valid_linkages(self.sent._obj)

        def next(self):
            if self.num == clg.sentence_num_valid_linkages(self.sent._obj):
                raise StopIteration()
            linkage = Linkage(self.num, self.sent, self.parse_options._obj)
            if not linkage:  # SAT sentinel value
                raise StopIteration()
            self.num += 1
            return linkage

        __next__ = next             # Account python3

    def parse(self, parse_options=None):
        return self.sentence_parse(self, parse_options)
