import itertools
import json
from datetime import timedelta

import pytest
from django.conf import settings
from django.contrib import auth
from django.urls import reverse
from django.utils import timezone
from django_scopes import scope

from cookbook.models import Recipe, SearchFields
from cookbook.tests.conftest import transpose
from cookbook.tests.factories import (CookLogFactory, FoodFactory, IngredientFactory,
                                      KeywordFactory, RecipeBookEntryFactory, RecipeFactory,
                                      UnitFactory, ViewLogFactory)

# TODO test combining any/all of the above
# TODO test sort_by
# TODO test sort_by new X number of recipes are new within last Y days
# TODO test loading custom filter
# TODO test loading custom filter with overrided params
# TODO makenow with above filters
# TODO test search food/keywords including/excluding children
LIST_URL = 'api:recipe-list'
sqlite = settings.DATABASES['default']['ENGINE'] != 'django.db.backends.postgresql'


@pytest.fixture
def accent():
    return "àbçđêf ğĦìĵķĽmñ öPqŕşŧ úvŵxyž"


@pytest.fixture
def unaccent():
    return "abcdef ghijklmn opqrst uvwxyz"


@pytest.fixture
def user1(request, space_1, u1_s1, unaccent):
    user = auth.get_user(u1_s1)
    try:
        params = {x[0]: x[1] for x in request.param}
    except AttributeError:
        params = {}
    result = 1
    misspelled_result = 0
    search_term = unaccent

    if params.get('fuzzy_lookups', False):
        user.searchpreference.lookup = True
        misspelled_result = 1
    else:
        user.searchpreference.lookup = False

    if params.get('fuzzy_search', False):
        user.searchpreference.trigram.set(SearchFields.objects.all())
        misspelled_result = 1
    else:
        user.searchpreference.trigram.set([])

    if params.get('icontains', False):
        user.searchpreference.icontains.set(SearchFields.objects.all())
        search_term = 'ghijklmn'
    else:
        user.searchpreference.icontains.set([])

    if params.get('istartswith', False):
        user.searchpreference.istartswith.set(SearchFields.objects.all())
        search_term = 'abcdef'
    else:
        user.searchpreference.istartswith.set([])

    if params.get('unaccent', False):
        user.searchpreference.unaccent.set(SearchFields.objects.all())
        misspelled_result *= 2
        result *= 2
    else:
        user.searchpreference.unaccent.set([])

    # full text vectors are hard coded to use unaccent - put this after unaccent to override result
    if params.get('fulltext', False):
        user.searchpreference.fulltext.set(SearchFields.objects.all())
        # user.searchpreference.search = 'websearch'
        search_term = 'ghijklmn uvwxyz'
        result = 2
    else:
        user.searchpreference.fulltext.set([])

    user.searchpreference.save()
    misspelled_term = transpose(search_term, number=3)
    return (u1_s1, result, misspelled_result, search_term, misspelled_term, params)


@pytest.fixture
def recipes(space_1):
    return RecipeFactory.create_batch(10, space=space_1)


@pytest.fixture
def found_recipe(request, space_1, accent, unaccent, u1_s1, u2_s1):
    user1 = auth.get_user(u1_s1)
    user2 = auth.get_user(u2_s1)
    days_3 = timezone.now() - timedelta(days=3)
    days_15 = timezone.now() - timedelta(days=15)
    days_30 = timezone.now() - timedelta(days=30)
    if request.param.get('createdon', None):
        recipe1 = RecipeFactory.create(space=space_1, created_at=days_3)
        recipe2 = RecipeFactory.create(space=space_1, created_at=days_30)
        recipe3 = RecipeFactory.create(space=space_1, created_at=days_15)

    else:
        recipe1 = RecipeFactory.create(space=space_1)
        recipe2 = RecipeFactory.create(space=space_1)
        recipe3 = RecipeFactory.create(space=space_1)
    obj1 = None
    obj2 = None

    if request.param.get('food', None):
        obj1 = FoodFactory.create(name=unaccent, space=space_1)
        obj2 = FoodFactory.create(name=accent, space=space_1)
        recipe1.steps.first().ingredients.add(IngredientFactory.create(food=obj1))
        recipe2.steps.first().ingredients.add(IngredientFactory.create(food=obj2))
        recipe3.steps.first().ingredients.add(IngredientFactory.create(
            food=obj1), IngredientFactory.create(food=obj2))
    if request.param.get('keyword', None):
        obj1 = KeywordFactory.create(name=unaccent, space=space_1)
        obj2 = KeywordFactory.create(name=accent, space=space_1)
        recipe1.keywords.add(obj1)
        recipe2.keywords.add(obj2)
        recipe3.keywords.add(obj1, obj2)
        recipe1.name = unaccent
        recipe2.name = accent
        recipe1.save()
        recipe2.save()
    if request.param.get('book', None):
        obj1 = RecipeBookEntryFactory.create(recipe=recipe1).book
        obj2 = RecipeBookEntryFactory.create(recipe=recipe2).book
        RecipeBookEntryFactory.create(recipe=recipe3, book=obj1)
        RecipeBookEntryFactory.create(recipe=recipe3, book=obj2)
    if request.param.get('unit', None):
        obj1 = UnitFactory.create(name=unaccent, space=space_1)
        obj2 = UnitFactory.create(name=accent, space=space_1)
        recipe1.steps.first().ingredients.add(IngredientFactory.create(unit=obj1))
        recipe2.steps.first().ingredients.add(IngredientFactory.create(unit=obj2))
        recipe3.steps.first().ingredients.add(IngredientFactory.create(
            unit=obj1), IngredientFactory.create(unit=obj2))
    if request.param.get('name', None):
        recipe1.name = unaccent
        recipe2.name = accent
        recipe1.save()
        recipe2.save()
    if request.param.get('description', None):
        recipe1.description = unaccent
        recipe2.description = accent
        recipe1.save()
        recipe2.save()
    if request.param.get('instruction', None):
        i1 = recipe1.steps.first()
        i2 = recipe2.steps.first()
        i1.instruction = unaccent
        i2.instruction = accent
        i1.save()
        i2.save()

    if request.param.get('viewedon', None):
        ViewLogFactory.create(recipe=recipe1, created_by=user1,
                              created_at=days_3, space=space_1)
        ViewLogFactory.create(recipe=recipe2, created_by=user1,
                              created_at=days_30, space=space_1)
        ViewLogFactory.create(recipe=recipe3, created_by=user2,
                              created_at=days_15, space=space_1)
    if request.param.get('cookedon', None):
        CookLogFactory.create(recipe=recipe1, created_by=user1,
                              created_at=days_3, space=space_1)
        CookLogFactory.create(recipe=recipe2, created_by=user1,
                              created_at=days_30, space=space_1)
        CookLogFactory.create(recipe=recipe3, created_by=user2,
                              created_at=days_15, space=space_1)
    if request.param.get('timescooked', None):
        CookLogFactory.create_batch(
            5, recipe=recipe1, created_by=user1, space=space_1)
        CookLogFactory.create(recipe=recipe2, created_by=user1, space=space_1)
        CookLogFactory.create_batch(
            3, recipe=recipe3, created_by=user2, space=space_1)
    if request.param.get('rating', None):
        CookLogFactory.create(
            recipe=recipe1, created_by=user1, rating=5.0, space=space_1)
        CookLogFactory.create(
            recipe=recipe2, created_by=user1, rating=1.0, space=space_1)
        CookLogFactory.create(
            recipe=recipe3, created_by=user2, rating=3.0, space=space_1)

    return (recipe1, recipe2, recipe3, obj1, obj2, request.param)


@pytest.mark.parametrize("found_recipe, param_type", [
    ({'food': True}, 'foods'),
    ({'keyword': True}, 'keywords'),
    ({'book': True}, 'books'),
], indirect=['found_recipe'])
@pytest.mark.parametrize('operator', [('_or', 3, 0), ('_and', 1, 2), ])
def test_search_or_and_not(found_recipe, param_type, operator, recipes, u1_s1, space_1):
    with scope(space=space_1):
        param1 = f"{param_type}{operator[0]}={found_recipe[3].id}"
        param2 = f"{param_type}{operator[0]}={found_recipe[4].id}"
        param1_not = f"{param_type}{operator[0]}_not={found_recipe[3].id}"
        param2_not = f"{param_type}{operator[0]}_not={found_recipe[4].id}"

        # testing include searches
        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param1}').content)
        assert r['count'] == 2
        assert found_recipe[0].id in [x['id'] for x in r['results']]
        assert found_recipe[2].id in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param2}').content)
        assert r['count'] == 2
        assert found_recipe[1].id in [x['id'] for x in r['results']]
        assert found_recipe[2].id in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) +
                       f'?{param1}&{param2}').content)
        assert r['count'] == operator[1]
        assert found_recipe[2].id in [x['id'] for x in r['results']]

        # testing _not searches
        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param1_not}').content)
        assert r['count'] == 11
        assert found_recipe[0].id not in [x['id'] for x in r['results']]
        assert found_recipe[2].id not in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param2_not}').content)
        assert r['count'] == 11
        assert found_recipe[1].id not in [x['id'] for x in r['results']]
        assert found_recipe[2].id not in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) +
                       f'?{param1_not}&{param2_not}').content)
        assert r['count'] == 10 + operator[2]
        assert found_recipe[2].id not in [x['id'] for x in r['results']]


@pytest.mark.parametrize("found_recipe", [
    ({'unit': True}),
], indirect=['found_recipe'])
def test_search_units(found_recipe, recipes, u1_s1, space_1):
    with scope(space=space_1):
        param1 = f"units={found_recipe[3].id}"
        param2 = f"units={found_recipe[4].id}"

        # testing include searches
        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param1}').content)
        assert r['count'] == 2
        assert found_recipe[0].id in [x['id'] for x in r['results']]
        assert found_recipe[2].id in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) + f'?{param2}').content)
        assert r['count'] == 2
        assert found_recipe[1].id in [x['id'] for x in r['results']]
        assert found_recipe[2].id in [x['id'] for x in r['results']]

        r = json.loads(u1_s1.get(reverse(LIST_URL) +
                       f'?{param1}&{param2}').content)
        assert r['count'] == 3
        assert found_recipe[2].id in [x['id'] for x in r['results']]


@pytest.mark.skipif(sqlite, reason="requires PostgreSQL")
@pytest.mark.parametrize("user1", itertools.product(
    [
        ('fuzzy_search', True), ('fuzzy_search', False),
        ('fuzzy_lookups', True), ('fuzzy_lookups', False)
    ],
    [('unaccent', True), ('unaccent', False)]
), indirect=['user1'])
@pytest.mark.parametrize("found_recipe, param_type", [
    ({'unit': True}, 'unit'),
    ({'keyword': True}, 'keyword'),
    ({'food': True}, 'food'),
], indirect=['found_recipe'])
def test_fuzzy_lookup(found_recipe, recipes, param_type, user1, space_1):
    with scope(space=space_1):
        list_url = f'api:{param_type}-list'
        param1 = f"query={user1[3]}"
        param2 = f"query={user1[4]}"

        r = json.loads(user1[0].get(reverse(list_url) +
                       f'?{param1}&limit=2').content)
        assert len([x['id'] for x in r['results'] if x['id'] in [
                   found_recipe[3].id, found_recipe[4].id]]) == user1[1]

        r = json.loads(user1[0].get(reverse(list_url) +
                       f'?{param2}&limit=10').content)
        assert len([x['id'] for x in r['results'] if x['id'] in [
                   found_recipe[3].id, found_recipe[4].id]]) == user1[2]

# commenting this out for general use - it is really slow
# it should be run on occasion to ensure everything still works
# @pytest.mark.skipif(sqlite and True, reason="requires PostgreSQL")
# @pytest.mark.parametrize("user1", itertools.product(
#     [
#         ('fuzzy_search', True), ('fuzzy_search', False),
#         ('fulltext', True), ('fulltext', False),
#         ('icontains', True), ('icontains', False),
#         ('istartswith', True), ('istartswith', False),
#     ],
#     [('unaccent', True), ('unaccent', False)]
# ), indirect=['user1'])
# @pytest.mark.parametrize("found_recipe", [
#     ({'name': True}),
#     ({'description': True}),
#     ({'instruction': True}),
#     ({'keyword': True}),
#     ({'food': True}),
# ], indirect=['found_recipe'])
# # user array contains: user client, expected count of search, expected count of mispelled search, search string, mispelled search string, user search preferences
# def test_search_string(found_recipe, recipes, user1, space_1):
#     with scope(space=space_1):
#         param1 = f"query={user1[3]}"
#         param2 = f"query={user1[4]}"

#         r = json.loads(user1[0].get(reverse(LIST_URL) + f'?{param1}').content)
#         assert len([x['id'] for x in r['results'] if x['id'] in [
#                    found_recipe[0].id, found_recipe[1].id]]) == user1[1]

#         r = json.loads(user1[0].get(reverse(LIST_URL) + f'?{param2}').content)
#         assert len([x['id'] for x in r['results'] if x['id'] in [
#                    found_recipe[0].id, found_recipe[1].id]]) == user1[2]


@pytest.mark.parametrize("found_recipe, param_type, result", [
    ({'viewedon': True}, 'viewedon', (1, 1)),
    ({'cookedon': True}, 'cookedon', (1, 1)),
    # created dates are not filtered by user
    ({'createdon': True}, 'createdon', (2, 12)),
    # updated dates are not filtered by user
    ({'createdon': True}, 'updatedon', (2, 12)),
], indirect=['found_recipe'])
def test_search_date(found_recipe, recipes, param_type, result, u1_s1, u2_s1, space_1):
    # force updated_at to equal created_at datetime
    with scope(space=space_1):
        for recipe in Recipe.objects.all():
            Recipe.objects.filter(id=recipe.id).update(
                updated_at=recipe.created_at)

    date = (timezone.now() - timedelta(days=15)).strftime("%Y-%m-%d")
    param1 = f"?{param_type}={date}"
    param2 = f"?{param_type}=-{date}"
    r = json.loads(u1_s1.get(reverse(LIST_URL) + f'{param1}').content)
    assert r['count'] == result[0]
    assert found_recipe[0].id in [x['id'] for x in r['results']]

    r = json.loads(u1_s1.get(reverse(LIST_URL) + f'{param2}').content)
    assert r['count'] == result[1]
    assert found_recipe[1].id in [x['id'] for x in r['results']]

    # test today's date returns for lte and gte searches
    r = json.loads(u2_s1.get(reverse(LIST_URL) + f'{param1}').content)
    assert r['count'] == result[0]
    assert found_recipe[2].id in [x['id'] for x in r['results']]

    r = json.loads(u2_s1.get(reverse(LIST_URL) + f'{param2}').content)
    assert r['count'] == result[1]
    assert found_recipe[2].id in [x['id'] for x in r['results']]


@pytest.mark.parametrize("found_recipe, param_type", [
    ({'rating': True}, 'rating'),
    ({'timescooked': True}, 'timescooked'),
], indirect=['found_recipe'])
def test_search_count(found_recipe, recipes, param_type, u1_s1, u2_s1, space_1):
    param1 = f'?{param_type}=3'
    param2 = f'?{param_type}=-3'
    param3 = f'?{param_type}=0'

    r = json.loads(u1_s1.get(reverse(LIST_URL) + param1).content)
    assert r['count'] == 1
    assert found_recipe[0].id in [x['id'] for x in r['results']]

    r = json.loads(u1_s1.get(reverse(LIST_URL) + param2).content)
    assert r['count'] == 1
    assert found_recipe[1].id in [x['id'] for x in r['results']]

    # test search for not rated/cooked
    r = json.loads(u1_s1.get(reverse(LIST_URL) + param3).content)
    assert r['count'] == 11
    assert (found_recipe[0].id or found_recipe[1].id) not in [
        x['id'] for x in r['results']]

    # test matched returns for lte and gte searches
    r = json.loads(u2_s1.get(reverse(LIST_URL) + param1).content)
    assert r['count'] == 1
    assert found_recipe[2].id in [x['id'] for x in r['results']]

    r = json.loads(u2_s1.get(reverse(LIST_URL) + param2).content)
    assert r['count'] == 1
    assert found_recipe[2].id in [x['id'] for x in r['results']]