import inspect
import random
from collections import defaultdict
from typing import Union


class LanguageError(Exception):
    """
    Thrown when an error is encountered in language construction.
    """


class ImprobableTemplateError(Exception):
    """
    Thrown when too many successive attempts to create a word which passes all
    language rules fails.
    """


class WeightedSet:
    """
    A set in which members each have a weight, used for selecting at random.

    Usage:
        >>> ws = WeightedSet(('foo', 1.0), ('bar', 0.5))
        >>> ws.random()
        ('foo', 1.0)
    """

    def __init__(self, *weighted_members: tuple):
        self.members = []
        self.weights = []
        if weighted_members:
            self.members, self.weights = list(zip(*weighted_members))

    def random(self) -> str:
        return random.choices(self.members, self.weights)[0]

    def __add__(self, obj):
        ws = WeightedSet()
        ws.members = self.members + obj.members
        ws.weights = self.weights + obj.weights
        return ws

    def __str__(self):
        return f"{self.members}\n{self.weights}"


class Syllable:
    """
    One syllable of a word. Used to populate a SyllableSet.

    A syllable template is a string consisting of one or more grapheme types
    separated by a vertical pipe (|). Multiple template strings can be
    concatenated together with commas. When words are constructed, each
    syllable is populated with a random sequence chosen by
    Language.add_grapheme().

    A syllable template must contain at least one 'vowel'.

    Syllables can be multiplied by integers to produce repeated templates.

    Usage:
        # A syllable consisting of either a vowel or a consonant, followed by
        # a vowel, followed by either a vowel or consonant.
        >>> foo = Syllable(template='vowel|consonant,vowel,consonant|vowel')

        # Example multiplication
        >>> print(Syllable(template='vowel|consonant') * 3)
        vowel|consonant vowel|consonant vowel|consonant
    """

    def __init__(self, template: str = "vowel|consonant"):
        self.template = template
        self.validate()

    def validate(self):
        if "vowel" not in self.template:
            raise LanguageError(
                f"Invalid syllable template {self.template}!\n"
                "Syllables must have at least one vowel in the template."
            )

    def __mul__(self, count: int):
        return Syllable(template=",".join([self.template] * count))

    __rmul__ = __mul__

    def __str__(self):
        return self.template


class SyllableSet(WeightedSet):
    """
    A WeightedSet that selects random syllables.

    Usage:
        >>> word = SyllableSet(
                (Syllable('vowel'), 1.0),
                (Syllable('vowel|consonant') * 2, 1.0),
                (syllable('vowel|consonant,vowel|consonant') * 3, 0.75)
            )
        >>> word.random()
        vowel consonant consonant vowel
    """

    def random(self) -> iter:
        for syllable in random.choices(self.members, self.weights)[0].template.split(","):
            grapheme_template = random.choice(syllable.split("|"))
            yield grapheme_template.lower()


class Language:
    """
    A class representing a language.

    Usage:
        >>> Common = Language(
                name="common",
                vowels=WeightedSet(("a", 1.0), ("e", 1.0), ("i", 1.0), ...),
                consonants=WeightedSet(("b", 0.5), ("c", 0.5), ("d", 0.5), ...),
                prefixes=WeightedSet(("re", 0.5), ("de", 0.5), ("", 1.0), ...),
                suffixes=WeightedSet(("ed", 0.5), ("ing", 0.5), ("", 1.0), ...),
                syllables=SyllableSet(
                        (Syllable('consonant|vowel'), 1.0),
                        (Syllable('consonant|vowel') * 2, 0.75),
                        ...
                    ),
                rules=set(callable1, callable2, ...),
                minimum_grapheme_count=2,
            )
        >>> Common.word()
        reibing

    How Words Are Constructed:

        The main interface for callers is word(), which returns a
        randomly-generated word in the language according to the following
        algorithm:

        1. Choose a random syllable from the syllable set
        2. For each grapheme in the syllable
            3. Choose a random grapheme template
            4. Choose a random sequence from the language for that grapheme
            5. Validate the word against the language rules
        6. Repeat 1-5 until a valid word is generated
        7. Add a prefix and suffix, if they are defined

        The following graphemes are supported by default:
            - vowel
            - consonant
            - prefix
            - suffix

        When graphemes are chosen, the following rules are applied:
            - Every syllable must have at least one vowel
            - A syllable may never have three consecutive consonants

    How Words Are Validated:

        Once a word has been constructed by populating syllable templates, it is
        tested against one or more language rules.

        The default rules are defined in language.rules.default_rules; they are:
            - the word must contain at least one vowel
            - the word must not contain 3 or more contiguous english vowels
            - the word must not contain 3 or more contiguous english consonants
            - the word must not consist of just one vowel, repeated

        Since it is possible to craft Syllables resulting in grapheme
        selections that rarely or never yield valid words, or rules that
        reject every word, an ImprobableTemplateError will be thrown if
        10 successive attempts to create a valid word fail.

    Extending Languages:

        Graphemes are populated by means of callbacks which select a member
        of the associated weighted set at random. Graphemes can be any string,
        so long as the Language class has a matching callback.

        To add support for a new grapheme type, define a method on your
        Language class called get_grapheme_TYPE, where TYPE is the string
        used in your Syllable templates. Examine test cases in test_types.py
        for examples.
    """

    def __init__(
        self,
        name: str,
        vowels: WeightedSet,
        consonants: WeightedSet,
        prefixes: WeightedSet,
        suffixes: WeightedSet,
        syllables: SyllableSet,
        rules: set = set(),
        minimum_grapheme_count: int = 1,
    ):
        """
        Args:
            name                   - friendly name for the language
            vowels                 - the weighted set of vowel graphemes
            consonants             - the weighted set of consonant graphemes
            prefixes               - the weighted set of prefix graphemes
            suffixes               - the weighted set of suffix graphemes
            rules                  - a set of rules callbacks; see above.
            minimum_grapheme_count - the minimum number of graphemes in each word
        """
        self.name = name
        self.vowels = vowels
        self.consonants = consonants
        self.prefixes = prefixes
        self.suffixes = suffixes
        self.rules = rules
        self.syllables = syllables
        self.minimum_grapheme_count = minimum_grapheme_count
        self.validate_syllable_set()

        self.handlers = dict([(n, v) for (n, v) in inspect.getmembers(self, inspect.ismethod) if n.startswith("get_")])

    def validate(self, word: str) -> bool:
        """
        Returns true if the given word is possible in the current language.
        """
        if not word:
            return False
        for rule in self.rules:
            if not rule(self, word):
                return False
        return True

    def validate_syllable_set(self):
        for syllable in self.syllables.members:
            if len(syllable.template.split(",")) < self.minimum_grapheme_count:
                raise ImprobableTemplateError(
                    f"Syllable {syllable} does not define enough graphemes ({self.minimum_grapheme_count} required)."
                )

    def validate_graphemes(self, graphemes: list) -> bool:
        if len(graphemes) < self.minimum_grapheme_count:
            return False

        last = ""
        count = 0
        for g in graphemes:
            if g == last:
                count += 1
                if count == 3:
                    return False
            else:
                count = 1
            last = g
        return True

    def word(self, count: int = 1) -> list:
        """
        Yields words composed of randomized phonemes built from a random word template.
        """
        words = []
        for _ in range(count):
            random_word = ""
            attempts = 0
            while not self.validate(random_word):
                if attempts == 10:
                    raise ImprobableTemplateError(
                        f"Exhausted all attempts to create a valid word. Last attempt: {random_word}. "
                        "If you're getting this a lot, try enabling debugging to see what rules are failing."
                    )
                graphemes = []
                random_word = ""
                while not self.validate_graphemes(graphemes):
                    graphemes = list(self.syllables.random())
                for grapheme in graphemes:
                    random_word = self.add_grapheme(random_word, grapheme)
                attempts += 1
            if self.prefixes:
                random_word = self.get_grapheme_prefix() + random_word
            if self.suffixes:
                random_word = random_word + self.get_grapheme_suffix()
            words.append(random_word)
        return words

    def add_grapheme(self, word: str, template: str) -> str:
        """
        Returns a random grapheme of a supported type. The class must support a method of the name:
            get_grapheme_{template}
        """
        template = template.lower()
        try:
            return word + self.handlers[f"get_grapheme_{template}"]()
        except KeyError:
            raise NotImplementedError(
                f"No handler found for grapheme template '{template}'. "
                f"Do you need to define get_grapheme_{template}()?\n"
                "Supported handlers: " + self.handlers.keys
            )

    def get_grapheme_consonant(self) -> str:
        return self.consonants.random()

    def get_grapheme_vowel(self) -> str:
        return self.vowels.random()

    def get_grapheme_prefix(self) -> str:
        return self.prefixes.random()

    def get_grapheme_suffix(self) -> str:
        return self.suffixes.random()

    def text(self, count: int = 25) -> str:
        phrases = []
        phrase = []
        for word in self.word(count):
            phrase.append(str(word))
            if len(phrase) >= random.randint(1, 12):
                phrases.append(" ".join(phrase))
                phrase = []
        if phrase:
            phrases.append(" ".join(phrase))

        paragraph = phrases[0].capitalize()
        for phrase in phrases[1:]:
            if random.choice([0, 0, 1]):
                paragraph = paragraph + random.choice("?!.") + " " + phrase.capitalize()
            else:
                paragraph = paragraph + ", " + phrase
        paragraph = paragraph + random.choice("?!.")
        return paragraph

    def copy(self):
        return self.__class__(
            name=self.name,
            vowels=self.vowels,
            consonants=self.consonants,
            prefixes=self.prefixes,
            suffixes=self.suffixes,
            rules=self.rules,
            syllables=self.syllables,
            minimum_grapheme_count=self.minimum_grapheme_count,
        )

    def __str__(self) -> str:
        return self.word()[0]


NameSet = SyllableSet


class Name(defaultdict):
    def __str__(self):
        return self["fullname"][0]


class NameTemplate(Syllable):
    def validate(self):
        pass


class NameGenerator:
    def __init__(
        self,
        language: Language,
        templates: NameSet,
        syllables: Union[SyllableSet, None] = None,
        names: Union[WeightedSet, None] = None,
        surnames: Union[WeightedSet, None] = None,
        nicknames: Union[WeightedSet, None] = None,
        adjectives: Union[WeightedSet, None] = None,
        titles: Union[WeightedSet, None] = None,
        counts: Union[WeightedSet, None] = None,
        affixes: Union[WeightedSet, None] = None,
        suffixes: Union[WeightedSet, None] = None,
    ):
        self.language = language.copy()
        if syllables:
            self.language.syllables = syllables
        self.templates = templates
        self._names = names
        self._surnames = surnames
        self._nicknames = nicknames
        self._adjectives = adjectives
        self._titles = titles
        self._counts = counts
        self._suffixes = suffixes
        self._affixes = affixes

        self.handlers = dict([(n, v) for (n, v) in inspect.getmembers(self, inspect.ismethod) if n.startswith("get_")])

    def name(self, count: int = 1) -> list:
        """
        Generate Name instances.
        """
        names = []
        for _ in range(count):
            name = Name(list)
            fullname = []
            for part in self.templates.random():
                thisname = self.add_part(part).strip()
                if not thisname:
                    continue
                name[part].append(thisname)
                fullname.append(thisname)
            name["fullname"] = " ".join(fullname)
            names.append(name)
        return names

    def add_part(self, template: str) -> str:
        template = template.lower()
        try:
            return self.handlers[f"get_{template}"]()
        except KeyError:
            raise NotImplementedError(
                f"No handler found for name template '{template}' on class {self.__class__.__name__}. "
                f"Do you need to define get_{template}()?\nSupported Handlers: "
                + ",".join(n for n in dir(self) if n.startswith("get_"))
            )

    def get_name(self) -> str:
        name = (self._names.random() if self._names else self.language.word())[0]
        return name.title()

    def get_surname(self) -> str:
        name = (self._surnames.random() if self._surnames else self.language.word())[0]
        if self._suffixes:
            name = name + self._suffixes.random()
        if len(name) == 1:
            name = f"{name}."
        return name.title()

    def get_adjective(self) -> str:
        return (self._adjectives.random() if self._adjectives else "").title()

    def get_affix(self) -> str:
        return self._affixes.random() if self._affixes else ""

    def get_title(self) -> str:
        return (self._titles.random() if self._titles else "").title()

    def get_the(self) -> str:
        return "the"

    def get_count(self) -> str:
        return self._counts.random() if self._counts else ""

    def get_nickname(self) -> str:
        name = (self._nicknames.random() if self._nicknames else "").title()
        if name:
            return '"' + name + '"'
        return ""

    def get_initial(self) -> str:
        return

    def __str__(self) -> str:
        return self.name()[0]["fullname"]


def equal_weights(terms: list, weight: float = 1.0, blank: bool = True) -> WeightedSet:
    ws = WeightedSet(*[(term, weight) for term in terms])
    if blank:
        ws = WeightedSet(("", 1.0)) + ws
    return ws