"""test_cliutil_searchterm - Unit tests for cliutil.SearchTerm"""
# Copyright © 2020  Brett Smith
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import re

import pytest

from . import testutil

from conservancy_beancount import cliutil
from conservancy_beancount import data

TICKET_LINKS = [
    '123',
    'rt:123',
    'rt://ticket/123',
]

ATTACHMENT_LINKS = [
    '123/456',
    'rt:123/456',
    'rt://ticket/123/attachments/456',
]

REPOSITORY_LINKS = [
    '789.pdf',
    'Documents/789.pdf',
]

RT_LINKS = TICKET_LINKS + ATTACHMENT_LINKS
ALL_LINKS = RT_LINKS + REPOSITORY_LINKS

INVALID_METADATA_KEYS = [
    # Must start with a-z
    ';key',
    ' key',
    'ákey',
    'Key',
    # Must only contain alphanumerics, -, and _
    'key;',
    'key ',
    'a.key',
]

@pytest.fixture(scope='module')
def defaults_parser():
    return cliutil.SearchTerm.arg_parser('document', 'rt-id')

@pytest.fixture(scope='module')
def one_default_parser():
    return cliutil.SearchTerm.arg_parser('default')

@pytest.fixture(scope='module')
def no_default_parser():
    return cliutil.SearchTerm.arg_parser()

def check_link_regexp(regexp, match_s, first_link_only=False):
    assert regexp
    assert re.search(regexp, match_s)
    assert re.search(regexp, match_s + ' postlink')
    assert re.search(regexp, match_s + '0') is None
    assert re.search(regexp, '1' + match_s) is None
    end_match = re.search(regexp, 'prelink ' + match_s)
    if first_link_only:
        assert end_match is None
    else:
        assert end_match

@pytest.mark.parametrize('arg', TICKET_LINKS)
def test_search_term_parse_ticket(defaults_parser, arg):
    key, regexp = defaults_parser(arg)
    assert key == 'rt-id'
    check_link_regexp(regexp, 'rt:123', first_link_only=True)
    check_link_regexp(regexp, 'rt://ticket/123', first_link_only=True)

@pytest.mark.parametrize('arg', ATTACHMENT_LINKS)
def test_search_term_parse_attachment(defaults_parser, arg):
    key, regexp = defaults_parser(arg)
    assert key == 'document'
    check_link_regexp(regexp, 'rt:123/456')
    check_link_regexp(regexp, 'rt://ticket/123/attachments/456')

@pytest.mark.parametrize('key,query', testutil.combine_values(
    ['approval', 'contract', 'invoice'],
    RT_LINKS,
))
def test_search_term_parse_metadata_rt_shortcut(defaults_parser, key, query):
    actual_key, regexp = defaults_parser(f'{key}={query}')
    assert actual_key == key
    if query.endswith('/456'):
        check_link_regexp(regexp, 'rt:123/456')
        check_link_regexp(regexp, 'rt://ticket/123/attachments/456')
    else:
        check_link_regexp(regexp, 'rt:123')
        check_link_regexp(regexp, 'rt://ticket/123')

@pytest.mark.parametrize('search_prefix', [
    '',
    'approval=',
    'contract=',
    'invoice=',
])
def test_search_term_parse_repo_link(defaults_parser, search_prefix):
    document = '1234.pdf'
    actual_key, regexp = defaults_parser(f'{search_prefix}{document}')
    if search_prefix:
        expect_key = search_prefix.rstrip('=')
    else:
        expect_key = 'document'
    assert actual_key == expect_key
    check_link_regexp(regexp, document)

@pytest.mark.parametrize('search,unmatched', [
    ('1234.pdf', '1234_pdf'),
])
def test_search_term_parse_regexp_escaping(defaults_parser, search, unmatched):
    _, regexp = defaults_parser(search)
    assert re.search(regexp, unmatched) is None

@pytest.mark.parametrize('key', INVALID_METADATA_KEYS)
def test_non_metadata_key(one_default_parser, key):
    document = f'{key}=890'
    key, pattern = one_default_parser(document)
    assert key == 'default'
    check_link_regexp(pattern, document)

@pytest.mark.parametrize('arg', ALL_LINKS)
def test_default_parser(one_default_parser, arg):
    key, _ = one_default_parser(arg)
    assert key == 'default'

@pytest.mark.parametrize('arg', ALL_LINKS + [
    f'{nonkey}={link}' for nonkey, link in testutil.combine_values(
        INVALID_METADATA_KEYS, ALL_LINKS,
    )
])
def test_no_key(no_default_parser, arg):
    with pytest.raises(ValueError):
        key, pattern = no_default_parser(arg)

@pytest.mark.parametrize('key', ['zero', 'one', 'two'])
def test_filter_postings(key):
    txn = testutil.Transaction(postings=[
        ('Income:Other', 3, {'one': '1', 'two': '2'}),
        ('Income:Other', 2, {'two': '2'}),
        ('Income:Other', 1, {'one': '1'}),
    ])
    search = cliutil.SearchTerm(key, '.')
    actual = list(search.filter_postings(data.Posting.from_txn(txn)))
    assert len(actual) == 0 if key == 'zero' else 2
    assert all(post.meta.get(key) for post in actual)