import os

from typing import Match

from medacy.data.data_file import DataFile

from medacy.data.annotations import Annotations

class Entity:

    """

    Representation of an individual entity in an annotation document. This abstraction is not used in the Annotations

    class, but can be used to keep track of what entities are present in a document during dataset manipulation.

    :ivar tag: the tag of this Entity

    :ivar start: the start index

    :ivar end: the end index

    :ivar text: the text of the Entity

    """

    t = 1

    def __init__(self, tag: str, start: int, end: int, text: str, num: int = 0):

        self.num = num

        self.tag = tag

        self.start = start

        self.end = end

        self.text = text

    def __eq__(self, other):

        return self.start == other.start and self.end == other.end and self.tag == other.tag

    def __hash__(self):

        return hash((self.start, self.end, self.text))

    def __str__(self):

        """Returns the BRAT representation of this Entity, without a new-line character"""

        return f"T{self.num}\t{self.tag} {self.start} {self.end}\t{self.text}"

    def __repr__(self):

        """Return the constructor in string form"""

        return f"{type(self).__name__}({self.tag}, {self.start}, {self.end}, {self.text}, {self.num})"

    @classmethod

    def reset_t(cls):

        """

        Resest the T counter for this class to 1

        :return: The previous value of t

        """

        previous = cls.t

        cls.t = 1

        return previous

    @classmethod

    def init_from_re_match(cls, match: Match, ent_class, num=None, increment_t=False):

        """

        Creates a new Entity from a regex Match.

        :param match: A Match object

        :param ent_class: The type of entity this is

        :param num: The number for this entity; defaults to the current entity count held by the class.

        :param increment_t: Whether or not to increment the T number

        :return: A new Entity

        """

        if not isinstance(match, Match):

            raise TypeError("Argument is not a Match object.")

        new_entity = cls(

            num=cls.t if num is None else num,

            tag=ent_class,

            start=match.start(),

            end=match.end(),

            text=match.string[match.start():match.end()],

        )

        if num is None and increment_t:

            # Increment the counter

            cls.t += 1

        return new_entity

    @classmethod

    def init_from_doc(cls, doc):

        """

        Creates a list of Entities for all entity annotations in a document.

        :param doc: can be a DataFile or str of a file path

        :return: a list of Entities

        """

        if isinstance(doc, DataFile):

            ann = Annotations(doc.ann_path, doc.txt_path)

        elif isinstance(doc, (str, os.PathLike)):

            ann = Annotations(doc)

        else:

            raise ValueError(f"'doc'' must be DataFile, str, or os.PathLike, but is '{type(doc)}'")

        entities = []

        for ent in ann:

            # Entities are a tuple of (label, start, end, text)

            new_ent = cls(

                tag=ent[0],

                start=ent[1],

                end=ent[2],

                text=ent[3]

            )

            entities.append(new_ent)

        return entities

    def set_t(self):

        """Sets the T value based on the class's counter and increments the counter"""

        self.num = self.__class__.t

        self.__class__.t += 1

    def equals(self, other, mode='strict'):

        """

        Determines if two Entities match, based on if the spans match and the tag is the same.

        If mode is set to 'lenient', two Entities match if the other span is fully within or fully

        without the first Entity and the tag is the same.

        :param other: another instance of Entity

        :param mode: 'strict' or 'lenient'; defaults to 'strict'

        :return: True or False

        """

        if not isinstance(other, Entity):

            raise ValueError(f"'other' must be another instance of Entity, but is '{type(other)}'")

        if mode == 'strict':

            return self == other

        if mode != 'lenient':

            raise ValueError(f"'mode' must be 'strict' or 'lenient', but is '{mode}'")

        # Lenient

        return ((self.end > other.start and self.start < other.end) or (self.start < other.end and other.start < self.end)) and self.tag == other.tag

def sort_entities(entities):

    """

    Sorts a list of Entity instances, adjusting the num value of each one

    :param entities: a list of Entities

    :return: a sorted list; all instances have ascending num values starting at 1

    """

    if not all(isinstance(e, Entity) for e in entities):

        raise ValueError("At least one item in entities is not an Entity")

    entities = entities.copy()

    entities.sort(key=lambda x: (x.start, x.end))

    for i, e in enumerate(entities, 1):

        e.num = i

    return entities