from typing import Literal

from common.utils import str_concept, unstr_concept
from helpers import get_metadata
from parsers.state_machine import MetadataToken, UnrecognizedToken


class MetadataTokenForTest(MetadataToken):
  def __repr__(self):
    res = f"(MetadataTokenForTest metadata={str_concept(self.metadata, drop_name=True)}"
    if self.start is not None:
      res += f", start={self.start}"
    if self.end is not None:
      res += f", end={self.end}"
    if self.resolution_method is not None:
      res += f", method={self.resolution_method}"
    if self.parser is not None:
      res += f", origin={self.parser}"
    
    res += ")"
    return res
  
  def __eq__(self, other):
    if not isinstance(other, MetadataToken):
      return False
    
    if self.metadata.id != other.metadata.id:
      return False
    
    if self.start is not None and self.start != other.start:
      return False
    
    if self.end is not None and self.end != other.end:
      return False
    
    if self.parser is not None and self.parser != other.parser:
      return False
    
    if self.resolution_method is not None and self.resolution_method != other.resolution_method:
      return False
    
    return True


def _ut(buffer, start=0, end=-1):
  """
  helper to UnrecognizedToken
  :param buffer:
  :type buffer:
  :param start:
  :type start:
  :param end:
  :type end:
  :return:
  :rtype:
  """
  return UnrecognizedToken(buffer, start, end)


def _mt(concept_id,
        start=0,
        end=-1,
        resolution_method: Literal["name", "key", "id"] = "key",
        parser="simple",
        **kwargs):
  """
  helper to MetadataToken
  :param concept_id:
  :type concept_id:
  :param start:
  :type start:
  :param end:
  :type end:
  :return:
  :rtype:
  """
  name, _id = unstr_concept(concept_id)
  variables = [(k, v) for k, v in kwargs.items()] if kwargs else None
  metadata = get_metadata(id=concept_id, variables=variables) if _id is None \
    else get_metadata(id=_id, name=name, variables=variables)
  return MetadataTokenForTest(metadata, start, end, resolution_method, parser)


def _mtsya(concept_id,
           start=0,
           end=None,
           resolution_method: Literal["name", "key", "id"] = "key",
           parser="sya",
           **kwargs):
  """
  helper to MetadataToken
  :param concept_id:
  :type concept_id:
  :param start:
  :type start:
  :param end:
  :type end:
  :return:
  :rtype:
  """
  name, _id = unstr_concept(concept_id)
  variables = [(k, v) for k, v in kwargs.items()] if kwargs else None
  metadata = get_metadata(id=concept_id, variables=variables) if _id is None \
    else get_metadata(id=_id, name=name, variables=variables)
  return MetadataTokenForTest(metadata, start, end, resolution_method, parser)