from typing import Any, Dict, List, Tuple
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,
]