import re
from lbrynet.schema.error import URIParseError

PROTOCOL = 'lbry://'
CHANNEL_CHAR = '@'
CLAIM_ID_CHAR = '#'
CLAIM_SEQUENCE_CHAR = ':'
BID_POSITION_CHAR = '$'
PATH_CHAR = '/'
QUERY_CHAR = '?'

CLAIM_ID_MAX_LENGTH = 40
CHANNEL_NAME_MIN_LENGTH = 1


class URI(object):
    __slots__ = ['name', 'claim_sequence', 'bid_position', 'claim_id', 'path']

    def __init__(self, name, claim_sequence=None, bid_position=None, claim_id=None, path=None):
        if len([v for v in [claim_sequence, bid_position, claim_id] if v is not None]) > 1:
            raise ValueError(
                "Only one of these may be present at a time: claim_sequence, bid_position, claim_id"
            )

        self.name = name
        self.claim_sequence = claim_sequence
        self.bid_position = bid_position
        self.claim_id = claim_id
        self.path = path

        if self.path is not None and not self.is_channel:
            raise ValueError("Content claims cannot have paths")

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

    def __eq__(self, other):
        for prop in self.__slots__:
            if not hasattr(other, prop) or getattr(self, prop) != getattr(other, prop):
                return False
        return self.__class__ == other.__class__

    @property
    def is_channel(self):
        return self.name.startswith(CHANNEL_CHAR)

    def to_uri_string(self):
        uri_string = PROTOCOL + "%s" % self.name

        if self.claim_sequence is not None:
            uri_string += CLAIM_SEQUENCE_CHAR + "%i" % self.claim_sequence
        elif self.bid_position is not None:
            uri_string += BID_POSITION_CHAR + "%i" % self.bid_position
        elif self.claim_id is not None:
            uri_string += CLAIM_ID_CHAR + "%s" % self.claim_id

        if self.path is not None:
            uri_string += PATH_CHAR + "%s" % self.path

        return uri_string

    def to_dict(self):
        return {
            "name": self.name,
            'claim_sequence': self.claim_sequence,
            'bid_position': self.bid_position,
            'claim_id': self.claim_id,
            'path': self.path,
        }

    @classmethod
    def from_uri_string(cls, uri_string):
        """
        Parses LBRY uri into its components

        :param uri_string: format - lbry://name:n$rank#id/path
                           optional modifiers:
                           claim_sequence (int): the nth claim to the name
                           bid_position (int): the bid queue position of the claim for the name
                           claim_id (str): the claim id for the claim
                           path (str): claim within a channel
        :return: URI
        """
        match = re.match(get_schema_regex(), uri_string)

        if match is None:
            raise URIParseError('Invalid URI')

        if match.group('content_name') and match.group('path'):
            raise URIParseError('Only channels may have paths')

        return cls(
            name=match.group("content_or_channel_name"),
            claim_sequence=int(match.group("claim_sequence")) if match.group(
                "claim_sequence") is not None else None,
            bid_position=int(match.group("bid_position")) if match.group(
                "bid_position") is not None else None,
            claim_id=match.group("claim_id"),
            path=match.group("path")
        )

    @classmethod
    def from_dict(cls, uri_dict):
        """
        Creates URI from dict

        :return: URI
        """
        return cls(**uri_dict)


def get_schema_regex():
    def _named(name, regex):
        return "(?P<" + name + ">" + regex + ")"

    def _group(regex):
        return "(?:" + regex + ")"

    # TODO: regex should include the fact that content names cannot have paths
    #       right now this is only enforced in code, not in the regex

    # Escape constants
    claim_id_char = re.escape(CLAIM_ID_CHAR)
    claim_sequence_char = re.escape(CLAIM_SEQUENCE_CHAR)
    bid_position_char = re.escape(BID_POSITION_CHAR)
    channel_char = re.escape(CHANNEL_CHAR)
    path_char = re.escape(PATH_CHAR)
    protocol = _named("protocol", re.escape(PROTOCOL))

    # Define basic building blocks
    valid_name_char = "[a-zA-Z0-9\-]"  # these characters are the only valid name characters
    name_content = valid_name_char + '+'
    name_min_channel_length = valid_name_char + '{' + str(CHANNEL_NAME_MIN_LENGTH) + ',}'

    positive_number = "[1-9][0-9]*"
    number = '\-?' + positive_number

    # Define URI components
    content_name = _named("content_name", name_content)
    channel_name = _named("channel_name", channel_char + name_min_channel_length)
    content_or_channel_name = _named("content_or_channel_name", content_name + "|" + channel_name)

    claim_id_piece = _named("claim_id", "[0-9a-f]{1," + str(CLAIM_ID_MAX_LENGTH) + "}")
    claim_id = _group(claim_id_char + claim_id_piece)

    bid_position_piece = _named("bid_position", number)
    bid_position = _group(bid_position_char + bid_position_piece)

    claim_sequence_piece = _named("claim_sequence", number)
    claim_sequence = _group(claim_sequence_char + claim_sequence_piece)

    modifier = _named("modifier", claim_id + "|" + bid_position + "|" + claim_sequence)

    path_piece = _named("path", name_content)
    path = _group(path_char + path_piece)

    # Combine components
    uri = _named("uri", (
        '^' +
        protocol + '?' +
        content_or_channel_name +
        modifier + '?' +
        path + '?' +
        '$'
    ))

    return uri


def parse_lbry_uri(lbry_uri):
    return URI.from_uri_string(lbry_uri)