"""
    pygments.lexers.algebra
    ~~~~~~~~~~~~~~~~~~~~~~~

    Lexers for computer algebra systems.

    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import re

from pygments.lexer import Lexer, RegexLexer, bygroups, do_insertions, words
from pygments.token import Text, Comment, Operator, Keyword, Name, String, Number, Punctuation, Generic, Whitespace

__all__ = ["GAPLexer", "GAPConsoleLexer", "MathematicaLexer", "MuPADLexer", "BCLexer"]


class GAPLexer(RegexLexer):
    """
    For GAP source code.

    .. versionadded:: 2.0
    """

    name = "GAP"
    url = "https://www.gap-system.org"
    aliases = ["gap"]
    filenames = ["*.g", "*.gd", "*.gi", "*.gap"]

    tokens = {
        "root": [
            (r"#.*$", Comment.Single),
            (r'"(?:[^"\\]|\\.)*"', String),
            (r"\(|\)|\[|\]|\{|\}", Punctuation),
            (
                r"""(?x)\b(?:
                if|then|elif|else|fi|
                for|while|do|od|
                repeat|until|
                break|continue|
                function|local|return|end|
                rec|
                quit|QUIT|
                IsBound|Unbind|
                TryNextMethod|
                Info|Assert
              )\b""",
                Keyword,
            ),
            (
                r"""(?x)\b(?:
                true|false|fail|infinity
              )\b""",
                Name.Constant,
            ),
            (
                r"""(?x)\b(?:
                (Declare|Install)([A-Z][A-Za-z]+)|
                   BindGlobal|BIND_GLOBAL
              )\b""",
                Name.Builtin,
            ),
            (r"\.|,|:=|;|=|\+|-|\*|/|\^|>|<", Operator),
            (
                r"""(?x)\b(?:
                and|or|not|mod|in
              )\b""",
                Operator.Word,
            ),
            (
                r"""(?x)
              (?:\w+|`[^`]*`)
              (?:::\w+|`[^`]*`)*""",
                Name.Variable,
            ),
            (r"[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?", Number),
            (r"\.[0-9]+(?:e[0-9]+)?", Number),
            (r".", Text),
        ],
    }

    def analyse_text(text):
        score = 0.0

        # Declaration part
        if re.search(
            r"(InstallTrueMethod|Declare(Attribute|Category|Filter|Operation"
            + r"|GlobalFunction|Synonym|SynonymAttr|Property))",
            text,
        ):
            score += 0.7

        # Implementation part
        if re.search(
            r"(DeclareRepresentation|Install(GlobalFunction|Method|"
            + r"ImmediateMethod|OtherMethod)|New(Family|Type)|Objectify)",
            text,
        ):
            score += 0.7

        return min(score, 1.0)


class GAPConsoleLexer(Lexer):
    """
    For GAP console sessions. Modeled after JuliaConsoleLexer.

    .. versionadded:: 2.14
    """

    name = "GAP session"
    aliases = ["gap-console", "gap-repl"]
    filenames = ["*.tst"]

    def get_tokens_unprocessed(self, text):
        gaplexer = GAPLexer(**self.options)
        start = 0
        curcode = ""
        insertions = []
        output = False
        error = False

        for line in text.splitlines(keepends=True):
            if line.startswith("gap> ") or line.startswith("brk> "):
                insertions.append((len(curcode), [(0, Generic.Prompt, line[:5])]))
                curcode += line[5:]
                output = False
                error = False
            elif not output and line.startswith("> "):
                insertions.append((len(curcode), [(0, Generic.Prompt, line[:2])]))
                curcode += line[2:]
            else:
                if curcode:
                    yield from do_insertions(insertions, gaplexer.get_tokens_unprocessed(curcode))
                    curcode = ""
                    insertions = []
                if line.startswith("Error, ") or error:
                    yield start, Generic.Error, line
                    error = True
                else:
                    yield start, Generic.Output, line
                output = True
            start += len(line)

        if curcode:
            yield from do_insertions(insertions, gaplexer.get_tokens_unprocessed(curcode))

    # the following is needed to distinguish Scilab and GAP .tst files
    def analyse_text(text):
        # GAP prompts are a dead give away, although hypothetical;y a
        # file in another language could be trying to compare a variable
        # "gap" as in "gap> 0.1". But that this should happen at the
        # start of a line seems unlikely...
        if re.search(r"^gap> ", text):
            return 0.9
        else:
            return 0.0


class MathematicaLexer(RegexLexer):
    """
    Lexer for Mathematica source code.

    .. versionadded:: 2.0
    """

    name = "Mathematica"
    url = "http://www.wolfram.com/mathematica/"
    aliases = ["mathematica", "mma", "nb"]
    filenames = ["*.nb", "*.cdf", "*.nbp", "*.ma"]
    mimetypes = [
        "application/mathematica",
        "application/vnd.wolfram.mathematica",
        "application/vnd.wolfram.mathematica.package",
        "application/vnd.wolfram.cdf",
    ]

    # http://reference.wolfram.com/mathematica/guide/Syntax.html
    operators = (
        ";;",
        "=",
        "=.",
        "!=" "==",
        ":=",
        "->",
        ":>",
        "/.",
        "+",
        "-",
        "*",
        "/",
        "^",
        "&&",
        "||",
        "!",
        "<>",
        "|",
        "/;",
        "?",
        "@",
        "//",
        "/@",
        "@@",
        "@@@",
        "~~",
        "===",
        "&",
        "<",
        ">",
        "<=",
        ">=",
    )

    punctuation = (",", ";", "(", ")", "[", "]", "{", "}")

    def _multi_escape(entries):
        return "(%s)" % ("|".join(re.escape(entry) for entry in entries))

    tokens = {
        "root": [
            (r"(?s)\(\*.*?\*\)", Comment),
            (r"([a-zA-Z]+[A-Za-z0-9]*`)", Name.Namespace),
            (r"([A-Za-z0-9]*_+[A-Za-z0-9]*)", Name.Variable),
            (r"#\d*", Name.Variable),
            (r"([a-zA-Z]+[a-zA-Z0-9]*)", Name),
            (r"-?\d+\.\d*", Number.Float),
            (r"-?\d*\.\d+", Number.Float),
            (r"-?\d+", Number.Integer),
            (words(operators), Operator),
            (words(punctuation), Punctuation),
            (r'".*?"', String),
            (r"\s+", Text.Whitespace),
        ],
    }


class MuPADLexer(RegexLexer):
    """
    A MuPAD lexer.
    Contributed by Christopher Creutzig <christopher@creutzig.de>.

    .. versionadded:: 0.8
    """

    name = "MuPAD"
    url = "http://www.mupad.com"
    aliases = ["mupad"]
    filenames = ["*.mu"]

    tokens = {
        "root": [
            (r"//.*?$", Comment.Single),
            (r"/\*", Comment.Multiline, "comment"),
            (r'"(?:[^"\\]|\\.)*"', String),
            (r"\(|\)|\[|\]|\{|\}", Punctuation),
            (
                r"""(?x)\b(?:
                next|break|end|
                axiom|end_axiom|category|end_category|domain|end_domain|inherits|
                if|%if|then|elif|else|end_if|
                case|of|do|otherwise|end_case|
                while|end_while|
                repeat|until|end_repeat|
                for|from|to|downto|step|end_for|
                proc|local|option|save|begin|end_proc|
                delete|frame
              )\b""",
                Keyword,
            ),
            (
                r"""(?x)\b(?:
                DOM_ARRAY|DOM_BOOL|DOM_COMPLEX|DOM_DOMAIN|DOM_EXEC|DOM_EXPR|
                DOM_FAIL|DOM_FLOAT|DOM_FRAME|DOM_FUNC_ENV|DOM_HFARRAY|DOM_IDENT|
                DOM_INT|DOM_INTERVAL|DOM_LIST|DOM_NIL|DOM_NULL|DOM_POLY|DOM_PROC|
                DOM_PROC_ENV|DOM_RAT|DOM_SET|DOM_STRING|DOM_TABLE|DOM_VAR
              )\b""",
                Name.Class,
            ),
            (
                r"""(?x)\b(?:
                PI|EULER|E|CATALAN|
                NIL|FAIL|undefined|infinity|
                TRUE|FALSE|UNKNOWN
              )\b""",
                Name.Constant,
            ),
            (r"\b(?:dom|procname)\b", Name.Builtin.Pseudo),
            (r"\.|,|:|;|=|\+|-|\*|/|\^|@|>|<|\$|\||!|\'|%|~=", Operator),
            (
                r"""(?x)\b(?:
                and|or|not|xor|
                assuming|
                div|mod|
                union|minus|intersect|in|subset
              )\b""",
                Operator.Word,
            ),
            (r"\b(?:I|RDN_INF|RD_NINF|RD_NAN)\b", Number),
            # (r'\b(?:adt|linalg|newDomain|hold)\b', Name.Builtin),
            (
                r"""(?x)
              ((?:[a-zA-Z_#][\w#]*|`[^`]*`)
              (?:::[a-zA-Z_#][\w#]*|`[^`]*`)*)(\s*)([(])""",
                bygroups(Name.Function, Text, Punctuation),
            ),
            (
                r"""(?x)
              (?:[a-zA-Z_#][\w#]*|`[^`]*`)
              (?:::[a-zA-Z_#][\w#]*|`[^`]*`)*""",
                Name.Variable,
            ),
            (r"[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?", Number),
            (r"\.[0-9]+(?:e[0-9]+)?", Number),
            (r"\s+", Whitespace),
            (r".", Text),
        ],
        "comment": [
            (r"[^/*]+", Comment.Multiline),
            (r"/\*", Comment.Multiline, "#push"),
            (r"\*/", Comment.Multiline, "#pop"),
            (r"[*/]", Comment.Multiline),
        ],
    }


class BCLexer(RegexLexer):
    """
    A BC lexer.

    .. versionadded:: 2.1
    """

    name = "BC"
    url = "https://www.gnu.org/software/bc/"
    aliases = ["bc"]
    filenames = ["*.bc"]

    tokens = {
        "root": [
            (r"/\*", Comment.Multiline, "comment"),
            (r'"(?:[^"\\]|\\.)*"', String),
            (r"[{}();,]", Punctuation),
            (
                words(
                    (
                        "if",
                        "else",
                        "while",
                        "for",
                        "break",
                        "continue",
                        "halt",
                        "return",
                        "define",
                        "auto",
                        "print",
                        "read",
                        "length",
                        "scale",
                        "sqrt",
                        "limits",
                        "quit",
                        "warranty",
                    ),
                    suffix=r"\b",
                ),
                Keyword,
            ),
            (r"\+\+|--|\|\||&&|" r"([-<>+*%\^/!=])=?", Operator),
            # bc doesn't support exponential
            (r"[0-9]+(\.[0-9]*)?", Number),
            (r"\.[0-9]+", Number),
            (r".", Text),
        ],
        "comment": [(r"[^*/]+", Comment.Multiline), (r"\*/", Comment.Multiline, "#pop"), (r"[*/]", Comment.Multiline)],
    }
