from io import StringIO

from django.core.management import call_command
from django.test import TestCase

from misago.acl import ACL_CACHE
from misago.cache.test import assert_invalidates_cache
from misago.categories.management.commands import fixcategoriestree
from misago.categories.models import Category


def run_command():
    """Run the management command"""
    command = fixcategoriestree.Command()
    out = StringIO()
    call_command(command, stdout=out)


class FixCategoriesTreeTests(TestCase):
    """
    The purpose is the verify that the management command
    fixes the lft/rght values of the thread category tree.
    """
    def setUp(self):
        Category.objects.create(name='Test', slug='test', parent=Category.objects.root_category())
        self.fetch_categories()

    def assertValidTree(self, expected_tree):
        root = Category.objects.root_category()
        queryset = Category.objects.filter(tree_id=root.tree_id).order_by('lft')

        current_tree = []
        for category in queryset:
            current_tree.append((category, category.get_level(), category.lft, category.rght))

        for i, category in enumerate(expected_tree):
            _category = current_tree[i]
            if category[0] != _category[0]:
                self.fail(('expected category at index #%s to be %s, '
                           'found %s instead') % (i, category[0], _category[0]))
            if category[1] != _category[1]:
                self.fail(('expected level at index #%s to be %s, '
                           'found %s instead') % (i, category[1], _category[1]))
            if category[2] != _category[2]:
                self.fail(('expected lft at index #%s to be %s, '
                           'found %s instead') % (i, category[2], _category[2]))
            if category[3] != _category[3]:
                self.fail(('expected lft at index #%s to be %s, '
                           'found %s instead') % (i, category[3], _category[3]))

    def fetch_categories(self):
        """gets a fresh version from the database"""
        self.root = Category.objects.root_category()
        self.first_category = Category.objects.get(slug='first-category')
        self.test_category = Category.objects.get(slug='test')

    def test_fix_categories_tree_unaffected(self):
        """Command should not affect a healthy three"""
        tree_id = self.root.tree_id
        run_command()

        self.fetch_categories()

        self.assertValidTree([
            (self.root, 0, 1, 6),
            (self.first_category, 1, 2, 3),
            (self.test_category, 1, 4, 5),
        ])

        self.assertEqual(self.root.tree_id, tree_id, msg="tree_id changed by command")

    def test_fix_categories_tree_affected(self):
        """Command should fix a broken tree"""
        # Root node with too narrow lft/rght range
        Category.objects.filter(id=self.root.id).update(lft=1, rght=4)
        # Make conflicting/identical lft/rght range
        Category.objects.filter(id=self.test_category.id).update(lft=2, rght=3)

        run_command()
        self.fetch_categories()

        self.assertValidTree([
            (self.root, 0, 1, 6),
            (self.test_category, 1, 2, 3),
            (self.first_category, 1, 4, 5),
        ])

    def test_fixing_categories_tree_invalidates_acl_cache(self):
        with assert_invalidates_cache(ACL_CACHE):
            run_command()