# coding=utf-8
# Copyright 2024 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import collections
import json
import random
import re
import string
import unicodedata

import langdetect
import spacy
from absl import logging

from lm_eval.tasks.ifeval.multilingual.instruction_utils import (
    es_instructions_util as instructions_util,
)


#The relational operation for comparison.
_COMPARISON_RELATION = ("at least", "less than")

#The maximum number of sentences.
_MAX_NUM_SENTENCES = 20

#The number of placeholders.
_NUM_PLACEHOLDERS = 4

#The number of bullet lists.
_NUM_BULLETS = 5

#The options of constrained response.
_CONSTRAINED_RESPONSE_OPTIONS = (
        "Sí.", "No.", "Quizás.")

#The options of starter keywords.
_STARTER_OPTIONS = ("Diría que", "Mi respuesta es", "Creo que",
                                        "En mi opinión", "Desde mi punto de vista",
                                        "El", "La", "Eso", "Un", "Una", "Para", "Por",
                                        "Entonces", "Ella", "Él")

# The options of ending keywords.
# TODO(jeffreyzhou) add more ending options
_ENDING_OPTIONS = ("Un saludo", "¿Necesitas algo más?", "Quedo pendiente de la siguiente consulta")

#The number of highlighted sections.
_NUM_HIGHLIGHTED_SECTIONS = 4

#The section spliter.
# _SECTION_SPLITER = ("Sección", "SECCIÓN")
_SECTION_SPLITER = [] # NOTE: Left empty intentionally to ensure that this is not used

#The number of sections.
_NUM_SECTIONS = 5

#The number of paragraphs.
_NUM_PARAGRAPHS = 5

#The postscript marker.
_POSTSCRIPT_MARKER = ("P.D.", "Nota")

#The number of keywords.
_NUM_KEYWORDS = 2

#The occurrences of a single keyword.
_KEYWORD_FREQUENCY = 3

#The occurrences of a single letter.
_LETTER_FREQUENCY = 20

#The occurrences of words with all letters.
_ALL_CAPITAL_WORD_FREQUENCY = 20

#The number of words in the response.
_NUM_WORDS_LOWER_LIMIT = 1
_NUM_WORDS_UPPER_LIMIT = 500

multilingual_nlp = spacy.load("xx_sent_ud_sm")

class Instruction:
    """An instruction template."""

    def __init__(self, instruction_id):
        self.id = instruction_id

    def build_description(self, **kwargs):
        raise NotImplementedError("`build_description` not implemented.")

    def get_instruction_args(self):
        raise NotImplementedError("`get_instruction_args` not implemented.")

    def get_instruction_args_keys(self):
        raise NotImplementedError("`get_instruction_args_keys` not implemented.")

    def check_following(self, value):
        raise NotImplementedError("`check_following` not implemented.")


class ResponseLanguageChecker(Instruction):
    """Check the language of the entire response."""

    def build_description(self, *, language = None):
        """Build the instruction description.

        Args:
            language: A string representing the expected language of the response. The
                language has to comply to the 97 types defined in
                `langid.py` (https://pypi.org/project/langid/1.1.5/), which follows
                ISO 639-1 codes (https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes);
                for example, `en` for English, `zh` for Chinese, `fr` for French.

        Returns:
            A string representing the instruction description.
        """
        self._language = language
        assert self._language

        self._description_pattern = (
                "Tu respuesta debe estar COMPLETAMENTE en {language}, ningún otro " +
                "idioma está permitido.")
        return self._description_pattern.format(language=instructions_util.lang_code_to_name(self._language))

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"language": self._language}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["language"]

    def check_following(self, value):
        """Check if the language of the entire response follows the instruction.

        Args:
            value: A string representing the response.

        Returns:
            True if the language of `value` follows instruction; otherwise False.
        """
        assert isinstance(value, str)

        try:
            return langdetect.detect(value) == self._language
        except langdetect.LangDetectException as e:
            # Count as instruction is followed.
            logging.error(
                    "Unable to detect language for text %s due to %s", value, e
            )  # refex: disable=pytotw.037
            return True


class NumberOfSentences(Instruction):
    """Check the number of sentences."""

    def build_description(self, *, num_sentences = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            num_sentences: An integer specifying the number of sentences as a
                threshold.
            relation: A string in (`como máximo` (at maximum), 'al menos' (at least)), defining the relational
                operator for comparison.
                Two relational comparisons are supported for now:
                if 'como máximo', the actual number of sentences <= the threshold;
                if 'al menos', the actual number of sentences >= the threshold.

        Returns:
            A string representing the instruction description.
        """
        # The number of sentences as a threshold for comparison.
        self._num_sentences_threshold = num_sentences
        if (self._num_sentences_threshold is None or
                self._num_sentences_threshold < 0):
            self._num_sentences_threshold = random.randint(1, _MAX_NUM_SENTENCES)

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "Tu respuesta debe contener {relation} {num_sentences} frases.")
        return self._description_pattern.format(
                relation=self._comparison_relation,
                num_sentences=self._num_sentences_threshold)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_sentences": self._num_sentences_threshold,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_sentences", "relation"]

    def check_following(self, value):
        """Check if the number of sentences follows the instruction.

        Args:
            value: A string representing the response.

        Returns:
            True if the response follows the instruction.

        Raise:
                ValueError if the string in `instruction_args` is not in
                [`al menos`, `como máximo`].
        """

        # Remove common bullet points like '-', '*', and numbered lists like '1.', '2.'
        #Only removes numbers that are bullet points because the pattern is anchored at the beginning of the sentence.
        cleaned_text = re.sub(r'(^\s*[\d]+\.\s*)|(^\s*[-*]\s*)', '', value, flags=re.MULTILINE)

        # Detect the language
        detected_lang = "es"  # Default to Spanish
        try:
                detected_lang = langdetect.detect(value.lower())
        except langdetect.lang_detect_exception.LangDetectException:
                # If language detection fails, default to Spanish
                pass

        if detected_lang == "es":
            num_sentences = instructions_util.count_sentences(cleaned_text)
        else:
            tokenized_text = multilingual_nlp(cleaned_text) 
            num_sentences = len(list(tokenized_text.sents))
            
        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return num_sentences >= self._num_sentences_threshold
        elif self._comparison_relation == _COMPARISON_RELATION[1]:
            return num_sentences <= self._num_sentences_threshold


class PlaceholderChecker(Instruction):
    """Check the placeholders in template writing."""

    def build_description(self, *, num_placeholders = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            num_placeholders: An integer denoting the minimum number of
                placeholders required in the response.
x
            relation: A string in (`como máximo` (at maximum), 'al menos' (at least)), defining the relational
                operator for comparison.

        Returns:
            A string representing the instruction description.
        """
        self._num_placeholders = num_placeholders
        if self._num_placeholders is None or self._num_placeholders < 0:
            self._num_placeholders = random.randint(1, _NUM_PLACEHOLDERS)

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "La respuesta debe contener {relation} {num_placeholders} marcadores de posición " +
                "representados por corchetes, como [dirección].")
        return self._description_pattern.format(
                relation=self._comparison_relation,
                num_placeholders=self._num_placeholders)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_placeholders": self._num_placeholders,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_placeholders", "relation"]

    def check_following(self, value):
        """Check if the number of placeholders follows the instruction.

        Args:
            value: A string representing the response.

        Returns:
            True if the actual number of placeholders in the response is greater than
            or equal to `num_placeholders`; otherwise, False.

            NOTE: The relation here is always (for the moment) "at least", so this checking
            method applies. If more relations are supported other than "at least",
            this method needs to be updated.
        """
        placeholders = re.findall(r"\[.*?\]", value)
        num_placeholders = len(placeholders)
        return num_placeholders >= self._num_placeholders


class BulletListChecker(Instruction):
    """Checks the bullet list in the prompt."""

    def build_description(self, *, num_bullets = None):
        """Build the instruction description.

        Args:
            num_bullets: An integer specifying the exact number of bullet lists
                that is required to appear in the response.

        Returns:
            A string representing the instruction description.
        """
        self._num_bullets = num_bullets
        if self._num_bullets is None or self._num_bullets < 0:
            self._num_bullets = random.randint(1, _NUM_BULLETS)
        self._description_pattern = (
                "Tu respuesta tiene que contener exactamente {num_bullets} puntos de lista. " +
                "Usa los puntos de lista de Markdown como:\n" +
                "* Este es el punto 1. \n" +
                "* Este es el punto 2")
        return self._description_pattern.format(
                num_bullets=self._num_bullets)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_bullets": self._num_bullets}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_bullets"]

    def check_following(self, value):
        """Check if the number of bullet lists meets the requirement.

        Args:
            value: A string representing the response. The response is expected to
                contain some bullet lists that start with `\*`.

        Returns:
            True if the actual number of bullet lists in the response meets the
            requirement.
        """
        bullet_lists = re.findall(r"^\s*\*[^\*].*$", value, flags=re.MULTILINE)
        num_bullet_lists = len(bullet_lists)
        return num_bullet_lists == self._num_bullets


class ConstrainedResponseChecker(Instruction):
    """Checks the constrained response."""

    def build_description(self):
        """Build the instruction description."""
        # A sequence of string(s) representing the options of the expected response ("Sí.", "No.", "Quizás.").
        self._constrained_responses = _CONSTRAINED_RESPONSE_OPTIONS
        self._description_pattern = (
                "Responde con alguna de las siguientes opciones: {response_options}")
        return self._description_pattern.format(
                response_options=self._constrained_responses)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response matches the constrained options.

        Args:
            value: A string representing the response.

        Returns:
            True if the actual response contains one of the options in the constrained
            responses; otherwise False.
        """
        value = value.strip()
        for constrained_response in self._constrained_responses:
            if constrained_response in value:
                return True
        return False

# ConstrainedStartChecker is not used in the current instructions, so this function has not
# been reviewed nor adapted to Spanish
class ConstrainedStartChecker(Instruction):
    """Checks the response start."""

    def build_description(self, *, starter = None):
        """Build the instruction description.

        Args:
            starter: A string representing the keyward that the response should start
                with.

        Returns:
            A string representing the instruction description.
        """
        self._starter = starter.strip() if isinstance(starter, str) else starter
        if self._starter is None:
            self._starter = random.choice(_STARTER_OPTIONS)
        self._description_pattern = (
                "During the conversation, when it is your turn, " +
                "please always start with {starter}")
        return self._description_pattern.format(starter=self._starter)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"starter": self._starter}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["starter"]

    def check_following(self, value):
        """Checks if the response starts with the constrained keyword or phrase.

        Args:
            value: A string representing the response.

        Returns:
            True if the response starts with the given phrase or keyword that is
            contained in `instruction_args`; otherwise, False.
        """
        response_pattern = r"^\s*" + self._starter + r".*$"
        response_with_constrained_start = re.search(response_pattern, value,
                                                                                                flags=re.MULTILINE)
        return True if response_with_constrained_start else False


class HighlightSectionChecker(Instruction):
    """Checks the highlighted section."""

    def build_description(self, *, num_highlights = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            num_highlights: An integer specifying the minimum number of highlighted
                sections.
            relation: A string in (`como máximo` (at maximum), 'al menos' (at least)), defining the relational
                operator for comparison.

        Returns:
            A string representing the instruction description.
        """
        self._num_highlights = num_highlights
        if self._num_highlights is None or self._num_highlights < 0:
            self._num_highlights = random.randint(1, _NUM_HIGHLIGHTED_SECTIONS)

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "Resalta {relation} {num_highlights} secciones en tu respuesta con " +
                "markdown, p.e. *sección subrayada*.")

        return self._description_pattern.format(
                relation=self._comparison_relation,
                num_highlights=self._num_highlights)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_highlights": self._num_highlights,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_highlights", "relation"]

    def check_following(self, value):
        """Checks if the number of highlighted sections meets the requirement.

        Args:
            value: a string repesenting the response. The response is expected to
                contain highlighted sections in the format of *highlighted*.

        Returns:
            True if the actual number of highlighted sections in the format of
            *highlighed sections* meets the minimum requirement; otherwise False.

            NOTE: The relation here is always (for the moment) "at least", so this checking
            method applies. If more relations are supported other than "at least",
            this method needs to be updated.
        """
        num_highlights = 0
        highlights = re.findall(r"\*[^\n\*]*\*", value)
        double_highlights = re.findall(r"\*\*[^\n\*]*\*\*", value)
        for highlight in highlights:
            if highlight.strip("*").strip():
                num_highlights += 1
        for highlight in double_highlights:
            if highlight.removeprefix("**").removesuffix("**").strip():
                num_highlights += 1

        return num_highlights >= self._num_highlights


class SectionChecker(Instruction):
    """Checks the sections."""

    def build_description(self, *, section_spliter = None,
                                                num_sections = None, relation = None):
        """Build the instruction description.

        Args:
            section_spliter: A string represents the section spliter keyword that
                marks a new section, i.e., `Sección` or `SECCIÓN`.
            num_sections: An integer specifying the number of sections.
            relation: A string in (`como máximo` (at maximum), 'al menos' (at least)), defining the relational
                operator for comparison.

        Returns:
            A string representing the instruction description.
        """
        self._section_spliter = section_spliter.strip() if isinstance(
                section_spliter, str) else section_spliter
        if self._section_spliter is None:
            self._section_spliter = random.choice(_SECTION_SPLITER)

        self._num_sections = num_sections
        if self._num_sections is None or self._num_sections < 0:
            self._num_sections = random.randint(1, _NUM_SECTIONS)

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "Tu respuesta debe tener {relation} {num_sections} secciones. Marca el principio " +
                "de cada sección con {section_spliter} X, tal como:\n" +
                "{section_spliter} 1\n" +
                "[contenido de sección 1]\n" +
                "{section_spliter} 2\n" +
                "[contenido de sección 2]")

        return self._description_pattern.format(
                num_sections=self._num_sections,
                section_spliter=self._section_spliter,
                relation=self._comparison_relation)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"section_spliter": self._section_spliter,
                        "num_sections": self._num_sections,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["section_spliter", "num_sections", "relation"]

    def check_following(self, value):
        """Checks the response contains multiple sections.

        Args:
            value: A string representing the response. The response is expected
                to contain multiple sections (number of sections is greater than 1).
                A new section starts with `Section 1`, where the number denotes the
                section index.

        Returns:
            True if the number of sections in the response is greater than or equal to
            the minimum number of sections; otherwise, False.

            NOTE: The relation here is always (for the moment) "at least", so this checking
            method applies. If more relations are supported other than "at least",
            this method needs to be updated.
        """
        section_splitter_patten = r"\s?" + self._section_spliter  + r"\s?\d+\s?"
        sections = re.split(section_splitter_patten, value)
        num_sections = len(sections) - 1
        return num_sections >= self._num_sections


class ParagraphChecker(Instruction):
    """Checks the paragraphs."""

    def build_description(self, *, num_paragraphs = None):
        """Build the instruction description.

        Args:
            num_paragraphs: An integer specifying the number of paragraphs.

        Returns:
            A string representing the instruction description.
        """
        self._num_paragraphs = num_paragraphs
        if self._num_paragraphs is None or self._num_paragraphs < 0:
            self._num_paragraphs = random.randint(1, _NUM_PARAGRAPHS)

        self._description_pattern = (
                "Debe haber {num_paragraphs} párrafos. " +
                "Los párrafos están separados por el divisor de markdown: ***")

        return self._description_pattern.format(num_paragraphs=self._num_paragraphs)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_paragraphs": self._num_paragraphs}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_paragraphs"]

    def check_following(self, value):
        """Checks the response contains required number of paragraphs.

        Args:
            value: A string representing the response. The response may contain
                paragraphs that are separated by the markdown divider: `***`.

        Returns:
            True if the actual number of paragraphs is the same as required;
            otherwise, False.
        """
        paragraphs = re.split(r"\s?\*\*\*\s?", value)
        num_paragraphs = len(paragraphs)

        for index, paragraph in enumerate(paragraphs):
            if not paragraph.strip():
                if index == 0 or index == len(paragraphs) - 1:
                    num_paragraphs -= 1
                else:
                    return False

        return num_paragraphs == self._num_paragraphs


class PostscriptChecker(Instruction):
    """Checks the postscript."""

    def build_description(self, *, postscript_marker = None
                                                ):
        """Build the instruction description.

        Args:
            postscript_marker: A string containing the keyword that marks the start
                of the postscript section.

        Returns:
            A string representing the instruction description.
        """
        self._postscript_marker = postscript_marker.strip() if isinstance(
                postscript_marker, str) else postscript_marker
        if self._postscript_marker is None:
            self._postscript_marker = random.choice(_POSTSCRIPT_MARKER)

        self._description_pattern = (
                "Al final de la respuesta, por favor añade explícitamente una posdata " +
                "que empiece por {postscript}")

        return self._description_pattern.format(postscript=self._postscript_marker)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"postscript_marker": self._postscript_marker}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["postscript_marker"]

    def check_following(self, value):
        """Checks if the response follows the postscript format.

        Args:
            value: a string representing the response. The response is expected to
                contain a postscript section.

        Returns:
            True if the response contains a postscript section starting with
            the keyword containing in the `instruction_args`; otherwise False.
        """
        value = value.lower()
        if self._postscript_marker == "P.D.":
            postscript_pattern = r"\s*p\.\s?d\..*$"
        elif self._postscript_marker == "Nota":
            postscript_pattern = r"\s*nota.*$"
        else:
            postscript_pattern = r"\s*" + self._postscript_marker.lower() + r".*$"
        postscript = re.findall(postscript_pattern, value, flags=re.MULTILINE)
        return True if postscript else False

# RephraseChecker is not used in the current instructions, so this +
# function has not been reviewed nor adapted to Spanish
class RephraseChecker(Instruction):
    """Checks the repharse."""

    def build_description(self, *, original_message):
        """Build the instruction description.

        Args:
            original_message: A string representing the original message. The
                rephrased response should only change its words/sentences in between
                its two asterisks, for example, *change me*. Both original and rephrased
                messages should contain the changes in the form of *change me*.

        Returns:
            A string representing the instruction description.
        """
        if not self.is_change(original_message):
            raise ValueError(f"Message {original_message} does not contain changes "
                                             "in the form of *change me*.")

        self._reference_without_change = original_message
        self._description = ("Rephrasing: Your rephrased response should only" +
                                                 "change the words/sentences in between two asterisks" +
                                                 "such as *change me*.")
        return self._description

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"original_message": self._reference_without_change}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["original_message"]

    def check_following(self, value):
        r"""Checks if the rephrasing follows the instruction.

        Args:
            value: A string representing the response, which is expected to rephras
                the string of `instruction_args`.

        Returns:
            True if `value` and `instruction_args` only differ by the words/sentences
            in between two asterisks such as *change me*; otherwise, False.
        """

        if not self.is_change(value):
            raise ValueError(f"value {value} does not contain "
                                             "changes in the form of *change me*.")

        response_without_changes = self.strip_changes(value)
        reference_without_changes = self.strip_changes(
                self._reference_without_change)

        return response_without_changes == reference_without_changes

    def is_change(self, response):
        """Check if there is change in the response in the form of *change me*."""
        return re.search(r"\*.*\*", response)

    def strip_changes(self, response):
        """Strips off the changes."""
        return re.sub(r"\*.*\*", "", response)


class KeywordChecker(Instruction):
    """Check the exisitence of certain keywords."""

    def build_description(self, *, keywords = None
                                                ):
        """Build the instruction description.

        Args:
            keywords: A sequence of strings representing the keywords that are
                expected in the response.

        Returns:
            A string representing the instruction description.
        """

        if not keywords:
            self._keywords = instructions_util.generate_keywords(
                    num_keywords=_NUM_KEYWORDS)
        else:
            self._keywords = keywords
        self._keywords = sorted(self._keywords)

        self._description_pattern = ("Incluye las palabras clave {keywords} en tu respuesta.")

        return self._description_pattern.format(keywords=self._keywords)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"keywords": self._keywords}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["keywords"]

    def check_following(self, value):
        """Check if the response contain the expected keywords."""
        for keyword in self._keywords:
            if not re.search(keyword, value, flags=re.IGNORECASE):
                return False
        return True


class KeywordFrequencyChecker(Instruction):
    """Check the keyword frequency."""

    def build_description(self, *, keyword = None,
                                                frequency = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            keyword: A string representing a keyword that is expected in the response.
            frequency: An integer specifying the number of times `keyword` is expected
                to appear in the response.
            relation: A string in (`como máximo`, `al menos'), defining the relational
                operator for comparison.
                Two relational comparisons are supported for now:
                if 'como máximo', the actual number of occurrences <= frequency;
                if 'al menos', the actual number of occurrences >= frequency.

        Returns:
            A string representing the instruction description.
        """
        if not keyword:
            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
        else:
            self._keyword = keyword.strip()

        self._frequency = frequency
        if self._frequency is None or self._frequency < 0:
            self._frequency = random.randint(1, _KEYWORD_FREQUENCY)

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "En tu respuesta, la palabra {keyword} debe aparecer {relation} " +
                "{frequency} veces.")

        return self._description_pattern.format(
                keyword=self._keyword,
                relation=self._comparison_relation,
                frequency=self._frequency)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"keyword": self._keyword,
                        "frequency": self._frequency,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["keyword", "frequency", "relation"]

    def check_following(self, value):
        """Checks if the response contain the keyword with required frequency."""
        actual_occurrences = len(re.findall(
                self._keyword, value, flags=re.IGNORECASE))

        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return actual_occurrences >= self._frequency
        elif self._comparison_relation == _COMPARISON_RELATION[1]:
            return actual_occurrences <= self._frequency


class NumberOfWords(Instruction):
    """Checks the number of words."""

    def build_description(self, *, num_words = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            num_words: An integer specifying the number of words contained in the
                response.
            relation: A string in (`Como máximo`, `al menos`), defining the relational
                operator for comparison.
                Two relational comparisons are supported for now:
                if 'less than', the actual number of words >= num_words;
                if 'at least', the actual number of words <= num_words.

        Returns:
            A string representing the instruction description.
        """

        self._num_words = num_words
        if self._num_words is None or self._num_words < 0:
            self._num_words = random.randint(
                    _NUM_WORDS_LOWER_LIMIT, _NUM_WORDS_UPPER_LIMIT
            )

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "Responde con {relation} {num_words} palabras.")

        return self._description_pattern.format(
                relation=self._comparison_relation,
                num_words=self._num_words)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_words": self._num_words,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_words", "relation"]

    def check_following(self, value):
        """Checks if the response contains the expected number of words."""

        # Remove common bullet points like '-', '*', and numbered lists like '1.', '2.'
        # Only removes numbers that are bullet points because the pattern is anchored at the beginning of the sentence.
        cleaned_text = re.sub(r'(^\s*[\d]+\.\s*)|(^\s*[-*]\s*)', '', value, flags=re.MULTILINE)
        cleaned_text_without_newlines = cleaned_text.replace('\n', ' ')
            
        num_words = instructions_util.count_words(cleaned_text_without_newlines)

        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return num_words >= self._num_words
        elif self._comparison_relation == _COMPARISON_RELATION[1]:
            return num_words <= self._num_words


class JsonFormat(Instruction):
    """Check the Json format."""

    def build_description(self):
        self._description_pattern = (
                "El output completo debe estar en formato JSON"
        )
        return self._description_pattern

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

# In the case of spanish instructions, this format with ``` is not requested, 
# but this is left here in case any evaluated output shows JSON code blocks in
# markdown format.
    def check_following(self, value):
        value = (
                value.strip()
                .removeprefix("```json")
                .removeprefix("```Json")
                .removeprefix("```JSON")
                .removeprefix("```")
                .removesuffix("```")
                .strip()
        )
        try:
            json.loads(value)
        except ValueError as _:
            return False
        return True


class ParagraphFirstWordCheck(Instruction):
    """Check the paragraph and the first word of the nth paragraph."""

    def build_description(self, num_paragraphs = None,
                                                nth_paragraph = None,
                                                first_word = None):
        r"""Build the instruction description.

        Args:
            num_paragraphs: An integer indicating the number of paragraphs expected
                in the response. A paragraph is a subset of the string that is
                expected to be separated by '\n\n'.
            nth_paragraph: An integer indicating the paragraph number that we look at.
                Note that n starts from 1.
            first_word: A string that represent the first word of the bth paragraph.

        Returns:
            A string representing the instruction description.
        """
        self._num_paragraphs = num_paragraphs
        if self._num_paragraphs is None or self._num_paragraphs < 0:
            self._num_paragraphs = random.randint(1, _NUM_PARAGRAPHS)

        self._nth_paragraph = nth_paragraph
        if (
                self._nth_paragraph is None
                or self._nth_paragraph <= 0
                or self._nth_paragraph > self._num_paragraphs
        ):
            self._nth_paragraph = random.randint(1, self._num_paragraphs + 1)

        self._first_word = first_word
        if self._first_word is None:
            self._first_word = instructions_util.generate_keywords(num_keywords=1)[0]
        self._first_word = self._first_word.lower()

        self._description_pattern = (
                "Debe haber {num_paragraphs} párrafos. " +
                "Párrafos y sólo párrafos estarán separados entre sí por dos " +
                "saltos de línea. El párrafo {nth_paragraph} debe comenzar con la " +
                "palabra {first_word}.")

        return self._description_pattern.format(
                num_paragraphs=self._num_paragraphs,
                nth_paragraph=self._nth_paragraph,
                first_word=self._first_word)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_paragraphs": self._num_paragraphs,
                        "nth_paragraph": self._nth_paragraph,
                        "first_word": self._first_word}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_paragraphs", "nth_paragraph", "first_word"]

    def check_following(self, value):
        """Checks for required number of paragraphs and correct first word.

        Args:
            value: a string representing the response. The response may contain
                paragraphs that are separated by two new lines and the first word of
                the nth paragraph will have to match a specified word.

        Returns:
            True if the number of paragraphs is the same as required and the first
            word of the specified paragraph is the same as required. Otherwise, false.
        """

        paragraphs = re.split(r"\n\n", value)
        num_paragraphs = len(paragraphs)

        for paragraph in paragraphs:
            if not paragraph.strip():
                num_paragraphs -= 1

        # check that index doesn't go out of bounds
        if self._nth_paragraph <= num_paragraphs:
            paragraph = paragraphs[self._nth_paragraph - 1].strip()
            if not paragraph:
                return False
        else:
            return False

        # Helper function to remove punctuation from a word
        def remove_punctuation(word):
                return ''.join(char for char in word if char not in string.punctuation)

        #Calculate how many words have to be extracted from the nth paragraph to compare
        expected_words = self._first_word.split()
        num_expected_words = len(expected_words)

        # Get words of the nth paragraph and remove punctuation
        paragraph_words = [remove_punctuation(word).lower() for word in paragraph.split()]

        # Return False if we are looking for more words than the paragraph has
        if len(paragraph_words) < num_expected_words:
                return False

        # Extract the first `num_expected_words` words from the paragraph
        extracted_words = paragraph_words[:num_expected_words]

        return (
                num_paragraphs == self._num_paragraphs
                and extracted_words == expected_words
        )


# TODO(jeffrey) add relation - at least/at most?
# KeySentenceChecker is not used in the current instructions, so this +
# function has not been reviewed nor adapted to Spanish
class KeySentenceChecker(Instruction):
    """Check the existence of certain key sentences."""

    def build_description(self, key_sentences = None,
                                                num_sentences = None):
        """Build the instruction description.

        Args:
            key_sentences: A sequences of strings representing the key sentences that
                are expected in the response.
            num_sentences: The number of key sentences that are expected to be seen in
                the response.

        Returns:
            A string representing the instruction description.
        """

        if not key_sentences:
            # TODO(jeffrey) make a generate sentences function? wonderwords package
            self._key_sentences = set(["For now, this is fine."])
        else:
            self._key_sentences = key_sentences

        if not num_sentences:
            self._num_sentences = random.randint(1, len(self._key_sentences))
        else:
            self._num_sentences = num_sentences

        self._description_pattern = (
                "Include {num_sentences} of the following sentences {key_sentences}"
        )

        return self._description_pattern.format(
                num_sentences=self._num_sentences, key_sentences=self._key_sentences
        )

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_sentences": self._num_sentences,
                        "key_sentences": list(self._key_sentences)}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_sentences", "key_sentences"]

    def check_following(self, value):
        """Checks if the response contains the expected key sentences."""
        count = 0
        sentences = instructions_util.split_into_sentences(value)
        for sentence in self._key_sentences:
            if sentence in sentences:
                count += 1

        return count == self._num_sentences


class ForbiddenWords(Instruction):
    """Checks that specified words are not used in response."""

    def build_description(self, forbidden_words = None
                                                ):
        """Build the instruction description.

        Args:
            forbidden_words: A sequences of strings respresenting words that are not
                allowed in the response.

        Returns:
            A string representing the instruction description.
        """

        if not forbidden_words:
            self._forbidden_words = instructions_util.generate_keywords(
                    num_keywords=_NUM_KEYWORDS)
        else:
            self._forbidden_words = list(set(forbidden_words))
        self._forbidden_words = sorted(self._forbidden_words)
        self._description_pattern = (
                "No incluyas las palabras clave {forbidden_words} en tu respuesta."
        )

        return self._description_pattern.format(
                forbidden_words=self._forbidden_words
        )

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"forbidden_words": self._forbidden_words}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["forbidden_words"]

    def check_following(self, value):
        """Check if the response does not contain the expected keywords."""
        for word in self._forbidden_words:
            if re.search(r"\b" + word + r"\b", value, flags=re.IGNORECASE):
                return False
        return True

# RephraseParagraph is not used in the current instructions, so this +
# function has not been reviewed nor adapted to Spanish yet
class RephraseParagraph(Instruction):
    """Checks that the paragraph is rephrased."""

    def build_description(self, *, original_paragraph, low, high
                                                ):
        """Builds the instruction description.

        Args:
            original_paragraph: A string presenting the original paragraph. The
                rephrases response should have betweeb low-high words in common.
            low: An integer presenting the lower bound of similar words.
            high: An integer representing the upper bound of similar words.

        Returns:
            A string representing the instruction description.
        """
        # TODO(jeffrey) make more encompassing
        self._original_paragraph = original_paragraph
        self._low = low
        self._high = high

        self._description = ("Rephrase the following paragraph: " +
                                                 "{original_paragraph}\nYour response should have " +
                                                 "between {low} and {high} of the same words. " +
                                                 "Words are the same if and only if all of the " +
                                                 "letters, ignoring cases, are the same. For " +
                                                 "example, 'run' is the same as 'Run' but different " +
                                                 "to 'ran'.")

        return self._description.format(original_paragraph=original_paragraph,
                                                                        low=self._low, high=self._high)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"original_paragraph": self._original_paragraph,
                        "low": self._low,
                        "high": self._high}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["original_paragraph", "low", "high"]

    def check_following(self, value):
        val_words = re.findall(r"\w+", value.lower())
        original_words = re.findall(r"\w+", self._original_paragraph.lower())
        similar_words = 0

        dict_val = collections.Counter(val_words)
        dict_original = collections.Counter(original_words)

        for word in dict_original:
            similar_words += min(dict_original[word], dict_val[word])

        return similar_words >= self._low and similar_words <= self._high


class TwoResponsesChecker(Instruction):
    """Check that two responses were given."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Da dos respuestas diferentes. Respuestas y sólo respuestas deben"
                " estar separadas por 6 símbolos de asterisco: ******."
        )
        return self._description_pattern

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response has two different answers.

        Args:
            value: A string representing the response.

        Returns:
            True if two responses are detected and false otherwise.
        """
        valid_responses = list()
        responses = value.split("******")
        for index, response in enumerate(responses):
            if not response.strip():
                if index != 0 and index != len(responses) - 1:
                    return False
            else:
                valid_responses.append(response)
        return (
                len(valid_responses) == 2
                and valid_responses[0].strip() != valid_responses[1].strip()
        )


class RepeatPromptThenAnswer(Instruction):
    """Checks that Prompt is first repeated then answered."""

    def build_description(self, *, prompt_to_repeat = None):
        """Build the instruction description.

        Args:
            prompt_to_repeat: The prompt that is meant to be repeated.

        Returns:
            A string representing the instruction description.
        """
        if not prompt_to_repeat:
            raise ValueError("prompt_to_repeat must be set.")
        else:
            self._prompt_to_repeat = prompt_to_repeat
        self._description_pattern = (
                "Primero, repite la petición sin cambios, luego da tu respuesta "
                "(no digas nada antes de repetir la petición; la petición que necesitas"
                " repetir no incluye esta frase)."
        )
        return self._description_pattern

    def get_instruction_args(self):
        return {"prompt_to_repeat": self._prompt_to_repeat}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["prompt_to_repeat"]

    def check_following(self, value):
        if value.strip().lower().startswith(self._prompt_to_repeat.strip().lower()):
            return True
        return False


class EndChecker(Instruction):
    """Checks that the prompt ends with a given phrase."""

    def build_description(self, *, end_phrase = None):
        """Build the instruction description.

        Args:
            end_phrase: A string representing the phrase the response should end with.

        Returns:
            A string representing the instruction description.
        """
        self._end_phrase = (
                end_phrase.strip() if isinstance(end_phrase, str) else end_phrase
        )
        if self._end_phrase is None:
            self._end_phrase = random.choice(_ENDING_OPTIONS)
        self._description_pattern = (
                "Termina tu respuesta con esta frase exacta {ender}. "
                "Ninguna otra palabra debe seguir esta frase.")
        return self._description_pattern.format(ender=self._end_phrase)

    def get_instruction_args(self):
        return {"end_phrase": self._end_phrase}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["end_phrase"]

    def check_following(self, value):
        """Checks if the response ends with the expected phrase."""
        value = value.strip().strip("\"").lower()
        self._end_phrase = self._end_phrase.strip().lower()
        # Check if the last character in value is a dot (.)
        if value and value[-1] == ".":
        # Remove the dot before checking if it ends with the expected end_phrase kwarg
                value = value[:-1]
        return value.endswith(self._end_phrase)


class TitleChecker(Instruction):
    """Checks the response for a title."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Tu respuesta debe contener un título, envuelto en dobles corchetes "
                "angulares, como <<poema de alegría>>."
        )
        return self._description_pattern

    def get_instruction_args(self):
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response contains a title."""
        pattern = r"<<[^\n]+>>"
        re_pattern = re.compile(pattern)
        titles = re.findall(re_pattern, value)

        for title in titles:
            if title.lstrip("<").rstrip(">").strip():
                return True
        return False


class LetterFrequencyChecker(Instruction):
    """Checks letter frequency."""

    def build_description(self, *, letter = None,
                                                let_frequency = None,
                                                let_relation = None):
        """Build the instruction description.

        Args:
            letter: A string representing a letter that is expected in the response.
            let_frequency: An integer specifying the number of times `keyword` is
                expected to appear in the response.
            let_relation: A string in (`less than`, `at least`), defining the
                relational operator for comparison. Two relational comparisons are
                supported for now; if 'less than', the actual number of
                occurrences < frequency; if 'at least', the actual number of
                occurrences >= frequency.

        Returns:
            A string representing the instruction description.
        """
        if (
                not letter
                or len(letter) > 1
                or ord(letter.lower()) < 97
                or ord(letter.lower()) > 122
        ):
            self._letter = random.choice(list(string.ascii_letters))
        else:
            self._letter = letter.strip()
        self._letter = self._letter.lower()

        self._frequency = let_frequency
        if self._frequency is None or self._frequency < 0:
            self._frequency = random.randint(1, _LETTER_FREQUENCY)

        if let_relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif let_relation not in _COMPARISON_RELATION:
            raise ValueError(
                    "The supported relation for comparison must be in "
                    f"{_COMPARISON_RELATION}, but {let_relation} is given."
            )
        else:
            self._comparison_relation = let_relation

        self._description_pattern = (
                "En tu respuesta, la letra {letter} debería aparecer {let_relation}"
                " {let_frequency} veces."
        )

        return self._description_pattern.format(
                letter=self._letter,
                let_frequency=self._frequency,
                let_relation=self._comparison_relation,
        )

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return {"letter": self._letter,
                        "let_frequency": self._frequency,
                        "let_relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["letter", "let_frequency", "let_relation"]

    def check_following(self, value):
        """Checks that the response contains the letter at the right frequency."""
        value = value.lower()
        letters = collections.Counter(value)

        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return letters[self._letter] >= self._frequency
        else:
            return letters[self._letter] <= self._frequency


class CapitalLettersSpanishChecker(Instruction):
    """Checks that the response is in spanish and is in all capital letters."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Tu respuesta debe estar en español al completo, sólo letras mayúsculas."
        )
        return self._description_pattern

    def get_instruction_args(self):
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks that the response is in Spanish and in all capital letters."""
        assert isinstance(value, str)

        # Normalize the string to handle accented characters and diacritics 
        # It decomposes the characters into their base form and diacritics, using the using the NFKD normalization form.
        normalized_value = unicodedata.normalize('NFKD', value)

        # Check if all normalized, alphabetic characters are uppercase, ignoring non-alphabetic characters
        is_uppercase = all(
                (c.isupper() or not c.isalpha()) for c in normalized_value
                if not unicodedata.combining(c)  # Skip diacritics
        )

        #NOTE: langdetect works with the original value since the decomposition of the characters in the normalization could affect the language detection.
        try:
            return is_uppercase and langdetect.detect(value.lower()) == "es"
        except langdetect.LangDetectException as e:
            # Count as instruction is followed.
            logging.error(
                    "Unable to detect language for text %s due to %s", value, e
            )  
            return True


class LowercaseLettersSpanishChecker(Instruction):
    """Checks that the response is in english and is in all lowercase letters."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Tu respuesta debe estar en español al completo, sólo letras "
                "minúsculas. Las letras mayúsculas no están permitidas."
        )
        return self._description_pattern

    def get_instruction_args(self):
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks that the response is in English and in all lowercase letters."""
        assert isinstance(value, str)

        try:
            return value.islower() and langdetect.detect(value) == "es"
        except langdetect.LangDetectException as e:
            # Count as instruction is followed.
            logging.error(
                    "Unable to detect language for text %s due to %s", value, e
            )  # refex: disable=pytotw.037
            return True


class CommaChecker(Instruction):
    """Checks the response for no commas."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "En la totalidad de la respuesta, abstente de usar comas."
        )
        return self._description_pattern

    def get_instruction_args(self):
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks that the response does not contain commas."""
        return not re.search(r"\,", value)


class CapitalWordFrequencyChecker(Instruction):
    """Checks frequency of words with all capital letters."""

    def build_description(
            self,
            capital_frequency = None,
            capital_relation = None,
    ):
        """Build the instruction description.

        Args:
            capital_frequency: An integer that represents the number of words that
                should be in all capital letters.
            capital_relation: A string that is 'at least' or 'at most' that refers to
                the frequency.

        Returns:
            A string representing the instruction description.
        """
        self._frequency = capital_frequency
        if self._frequency is None:
            self._frequency = random.randint(1, _ALL_CAPITAL_WORD_FREQUENCY)

        self._comparison_relation = capital_relation
        if capital_relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif capital_relation not in _COMPARISON_RELATION:
            raise ValueError(
                    "The supported relation for comparison must be in "
                    f"{_COMPARISON_RELATION}, but {capital_relation} is given."
            )

        self._description_pattern = (
                "En tu respuesta, palabras escritas al completo con letras mayúsculas "
                "deberían aparecer {relation} {frequency} veces."
        )

        return self._description_pattern.format(
                frequency=self._frequency, relation=self._comparison_relation
        )

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return {
                "capital_frequency": self._frequency,
                "capital_relation": self._comparison_relation,
        }

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["capital_frequency", "capital_relation"]

    def check_following(self, value):
        """Checks the frequency of words with all capital letters."""
        # Hyphenated words will usually count as one word using Spacy
        words = instructions_util.tokenize_words(value)
        capital_words = [word for word in words if word.isupper()]

        capital_words = len(capital_words)

        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return capital_words >= self._frequency
        else:
            return capital_words <= self._frequency


class QuotationChecker(Instruction):
    """Checks response is wrapped with double quotation marks."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Envuelve la totalidad de tu respuesta en comillas dobles."
        )
        return self._description_pattern

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response is wrapped with double quotation marks."""
        value = value.strip()
        return len(value) > 1 and value[0] == '"' and value[-1] == '"'


class QuestionMarkChecker(Instruction):
    """Checks response includes a question wrapped with question marks ¿?."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Tu respuesta debe incluir una pregunta."
        )
        return self._description_pattern

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response contains a question."""
        pattern = r"¿[^?]*\?"
        re_pattern = re.compile(pattern)
        questions = re.findall(re_pattern, value)

        for question in questions:
            if question.lstrip("¿").rstrip("?").strip():
                return True
        return False


class ExclamationMarkChecker(Instruction):
    """Checks response includes a question wrapped with question marks ¿?."""

    def build_description(self):
        """Build the instruction description."""
        self._description_pattern = (
                "Tu respuesta debe incluir una exclamación."
        )
        return self._description_pattern

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return None

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return []

    def check_following(self, value):
        """Checks if the response contains a question."""
        pattern = r"¡[^!]*\!"
        re_pattern = re.compile(pattern)
        exclamations = re.findall(re_pattern, value)

        for exclamation in exclamations:
            if exclamation.lstrip("¡").rstrip("!").strip():
                return True
        return False


class EnieChecker(Instruction):
    """Checks frequency of words with Spanish special character ñ (enie)."""

    def build_description(
            self,
            let_frequency = None,
    ):
        """Build the instruction description.

        Args:
            let_frequency: An integer that represents the number of words that
                contains the letter enie.

        Returns:
            A string representing the instruction description.
        """
        self._frequency = let_frequency
        if self._frequency is None:
            self._frequency = random.randint(1, _LETTER_FREQUENCY)

        self._description_pattern = (
                "En tu respuesta, palabras con la letra ñ deben aparecer "
                "{frequency} veces."
        )

        return self._description_pattern.format(
                frequency=self._frequency,
        )

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return {
                "let_frequency": self._frequency
        }

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["let_frequency"]

    def check_following(self, value):
        """Checks the frequency of words containing ñ."""
        # Hyphenated words will usually count as one word using Spacy
        words = instructions_util.tokenize_words(value)

        # Filter words that contain 'ñ'
        words_with_enie = [word for word in words if 'ñ' in word.lower()]

        # Count the number of words with 'ñ'
        num_words_with_enie = len(words_with_enie)

        return num_words_with_enie == self._frequency


class DieresisChecker(Instruction):
    """Checks frequency of words with Spanish special character ü (dieresis)."""

    def build_description(
            self,
            let_frequency = None,
    ):
        """Build the instruction description.

        Args:
            let_frequency: An integer that represents the number of words that
                contains a dieresis.

        Returns:
            A string representing the instruction description.
        """
        self._frequency = let_frequency
        if self._frequency is None:
            self._frequency = random.randint(1, _LETTER_FREQUENCY)

        self._description_pattern = (
                "En tu respuesta, palabras con la letra ü deben aparecer "
                "{frequency} veces."
        )

        return self._description_pattern.format(
                frequency=self._frequency,
        )

    def get_instruction_args(self):
        """Returns the keyword args of build description."""
        return {
                "let_frequency": self._frequency
        }

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["let_frequency"]

    def check_following(self, value):
        """Checks the frequency of words containing dieresis."""
        # Hyphenated words will usually count as one word using Spacy
        words = instructions_util.tokenize_words(value)

        # Filter words that contain 'ü'
        words_with_dieresis = [word for word in words if 'ü' in word.lower()]

        # Count the number of words with 'ü'
        num_words_with_dieresis = len(words_with_dieresis)

        return num_words_with_dieresis == self._frequency


class TildesChecker(Instruction):
    """Checks frequency of words with tildes."""

    def build_description(self, *, num_words = None,
                                                relation = None):
        """Build the instruction description.

        Args:
            num_words: An integer specifying the number of words contained in the
                response.
            relation: A string in (`Como máximo`, `al menos`), defining the relational
                operator for comparison.
                Two relational comparisons are supported for now:
                if 'less than', the actual number of words >= num_words;
                if 'at least', the actual number of words <= num_words.

        Returns:
            A string representing the instruction description.
        """

        self._num_words = num_words
        if self._num_words is None or self._num_words < 0:
            self._num_words = random.randint(
                    _NUM_WORDS_LOWER_LIMIT, _NUM_WORDS_UPPER_LIMIT
            )

        if relation is None:
            self._comparison_relation = random.choice(_COMPARISON_RELATION)
        elif relation not in _COMPARISON_RELATION:
            raise ValueError("The supported relation for comparison must be in "
                                             f"{_COMPARISON_RELATION}, but {relation} is given.")
        else:
            self._comparison_relation = relation

        self._description_pattern = (
                "Responde con {relation} {num_words} palabras con tilde.")

        return self._description_pattern.format(
                relation=self._comparison_relation,
                num_words=self._num_words)

    def get_instruction_args(self):
        """Returns the keyward args of `build_description`."""
        return {"num_words": self._num_words,
                        "relation": self._comparison_relation}

    def get_instruction_args_keys(self):
        """Returns the args keys of `build_description`."""
        return ["num_words", "relation"]

    def check_following(self, value):
        """Checks if the response contains the expected number of words with tildes."""
        accented_characters = "áéíóúÁÉÍÓÚ"
        words = instructions_util.tokenize_words(value)

        # Filter words that contain any of the accented characters
        words_with_tildes = [word for word in words if any(char in accented_characters for char in word)]

        # Hyphenated words will usually count as one word using Spacy
        num_words_with_tildes = len(words_with_tildes)

        if self._comparison_relation == _COMPARISON_RELATION[0]:
            return num_words_with_tildes >= self._num_words
        elif self._comparison_relation == _COMPARISON_RELATION[1]:
            return num_words_with_tildes <= self._num_words