from typing import List

from zulint.custom_rules import RuleList

MYPY = False
if MYPY:
    from zulint.custom_rules import Rule

whitespace_rules = [
    # This linter should be first since bash_rules depends on it.
    {"pattern": r"\s+$", "strip": "\n", "description": "Fix trailing whitespace"},
    {"pattern": "\t", "strip": "\n", "description": "Fix tab-based whitespace"},
]  # type: List[Rule]

markdown_whitespace_rules = list(
    rule for rule in whitespace_rules if rule["pattern"] != r"\s+$"
) + [
    # Two spaces trailing a line with other content is okay--it's a markdown line break.
    # This rule finds one space trailing a non-space, three or more trailing spaces, and
    # spaces on an empty line.
    {
        "pattern": r"((?<!\s)\s$)|(\s\s\s+$)|(^\s+$)",
        "strip": "\n",
        "description": "Fix trailing whitespace",
    },
    {
        "pattern": r"^#+[A-Za-z0-9]",
        "strip": "\n",
        "description": "Missing space after # in heading",
    },
]

python_rules = RuleList(
    langs=["py"],
    rules=[
        {"pattern": r'".*"%\([a-z_].*\)?$', "description": 'Missing space around "%"'},
        {"pattern": r"'.*'%\([a-z_].*\)?$", "description": 'Missing space around "%"'},
        # This rule is constructed with + to avoid triggering on itself
        {"pattern": r" =" + r'[^ =>~"]', "description": 'Missing whitespace after "="'},
        {"pattern": r'":\w[^"]*$', "description": 'Missing whitespace after ":"'},
        {"pattern": r"':\w[^']*$", "description": 'Missing whitespace after ":"'},
        {"pattern": r"^\s+[#]\w", "strip": "\n", "description": 'Missing whitespace after "#"'},
        {
            "pattern": r"assertEquals[(]",
            "description": "Use assertEqual, not assertEquals (which is deprecated).",
        },
        {
            "pattern": r"self: Any",
            "description": "you can omit Any annotation for self",
            "good_lines": ["def foo (self):"],
            "bad_lines": ["def foo(self: Any):"],
        },
        {"pattern": r"== None", "description": "Use `is None` to check whether something is None"},
        {"pattern": r"type:[(]", "description": 'Missing whitespace after ":" in type annotation'},
        {"pattern": r"# type [(]", "description": "Missing : after type in type annotation"},
        {"pattern": r"#type", "description": 'Missing whitespace after "#" in type annotation'},
        {"pattern": r"if[(]", "description": "Missing space between if and ("},
        {"pattern": r", [)]", "description": 'Unnecessary whitespace between "," and ")"'},
        {"pattern": r"%  [(]", "description": 'Unnecessary whitespace between "%" and "("'},
        # This next check could have false positives, but it seems pretty
        # rare; if we find any, they can be added to the exclude list for
        # this rule.
        {
            "pattern": r" % [a-zA-Z0-9_.]*\)?$",
            "description": "Used % comprehension without a tuple",
        },
        {
            "pattern": r".*%s.* % \([a-zA-Z0-9_.]*\)$",
            "description": "Used % comprehension without a tuple",
        },
        {
            "pattern": r"__future__",
            "include_only": {"zulip_bots/zulip_bots/bots/"},
            "description": "Bots no longer need __future__ imports.",
        },
        {
            "pattern": r"#!/usr/bin/env python$",
            "include_only": {"zulip_bots/"},
            "description": "Python shebangs must be python3",
        },
        {
            "pattern": r"(^|\s)open\s*\(",
            "description": "open() should not be used in Zulip's bots. Use functions"
            " provided by the bots framework to access the filesystem.",
            "include_only": {"zulip_bots/zulip_bots/bots/"},
        },
        {
            "pattern": r"pprint",
            "description": "Used pprint, which is most likely a debugging leftover. For user output, use print().",
        },
        {
            "pattern": r"\(BotTestCase\)",
            "bad_lines": ["class TestSomeBot(BotTestCase):"],
            "description": "Bot test cases should directly inherit from BotTestCase *and* DefaultTests.",
        },
        {
            "pattern": r"\(DefaultTests, BotTestCase\)",
            "bad_lines": ["class TestSomeBot(DefaultTests, BotTestCase):"],
            "good_lines": ["class TestSomeBot(BotTestCase, DefaultTests):"],
            "description": "Bot test cases should inherit from BotTestCase before DefaultTests.",
        },
        *whitespace_rules,
    ],
    max_length=140,
)

bash_rules = RuleList(
    langs=["sh"],
    rules=[
        {
            "pattern": r"#!.*sh [-xe]",
            "description": "Fix shebang line with proper call to /usr/bin/env for Bash path, change -x|-e switches"
            " to set -x|set -e",
        },
        *whitespace_rules[0:1],
    ],
)


json_rules = RuleList(
    langs=["json"],
    # Here, we don't check tab-based whitespace, because the tab-based
    # whitespace rule flags a lot of third-party JSON fixtures
    # under zerver/webhooks that we want preserved verbatim.  So
    # we just include the trailing whitespace rule and a modified
    # version of the tab-based whitespace rule (we can't just use
    # exclude in whitespace_rules, since we only want to ignore
    # JSON files with tab-based whitespace, not webhook code).
    rules=whitespace_rules[0:1],
)

prose_style_rules = [
    {
        "pattern": r'[^\/\#\-"]([jJ]avascript)',  # exclude usage in hrefs/divs
        "description": "javascript should be spelled JavaScript",
    },
    {
        "pattern": r"""[^\/\-\."'\_\=\>]([gG]ithub)[^\.\-\_"\<]""",  # exclude usage in hrefs/divs
        "description": "github should be spelled GitHub",
    },
    {
        "pattern": r"[oO]rganisation",  # exclude usage in hrefs/divs
        "description": "Organization is spelled with a z",
    },
    {"pattern": r"!!! warning", "description": "!!! warning is invalid; it's spelled '!!! warn'"},
    {
        "pattern": r"[^-_]botserver(?!rc)|bot server",
        "description": "Use Botserver instead of botserver or Botserver.",
    },
]  # type: List[Rule]

markdown_docs_length_exclude = {
    "zulip_bots/zulip_bots/bots/converter/doc.md",
}

markdown_rules = RuleList(
    langs=["md"],
    rules=[
        *markdown_whitespace_rules,
        *prose_style_rules,
        {
            "pattern": r"\[(?P<url>[^\]]+)\]\((?P=url)\)",
            "description": "Linkified markdown URLs should use cleaner <http://example.com> syntax.",
        },
    ],
    max_length=120,
    length_exclude=markdown_docs_length_exclude,
)

txt_rules = RuleList(
    langs=["txt"],
    rules=whitespace_rules,
)

non_py_rules = [
    json_rules,
    markdown_rules,
    bash_rules,
    txt_rules,
]