#!/usr/bin/python3
# -*- encoding: utf-8 -*-
import logging
try:
    import unittest2 as unittest
except ImportError:
    import unittest

import clitests

from abrtcli.match import (get_match_data,
                           match_completer,
                           match_get_problem,
                           match_lookup)

from abrtcli.utils import captured_output


class MatchTestCase(clitests.TestCase):
    '''
    Simple test to check if database creation & access
    works as expected.
    '''

    hashes = ['ccacca5', 'bc60a5c', 'acbea5c', 'ffe635c']
    collision_hash = 'bc60a5c'
    human = ['/home/user/bin/user_app', 'unknown_problem', 'polkitd']
    collision_human = 'pavucontrol'
    combined = ['pavucontrol@bc60a5c', 'pavucontrol@acbea5c']

    def test_get_match_data(self):
        '''
        Test get_match_data returns correctly merged data
        '''

        by_human_id, by_short_id = get_match_data()
        self.assertEqual(len(by_human_id), 4)

        self.assertEqual(len(by_short_id), 4)

    def test_match_completer(self):
        '''
        Test that match_completer yields properly formatted candidates
        '''

        pm = match_completer(None, None)
        self.assertEqual(set(pm), set(self.hashes + self.human + self.combined))

    def test_match_lookup_hash(self):
        '''
        Test match lookup by hash
        '''

        for h in self.hashes:
            m = match_lookup(h)
            self.assertTrue(len(m) >= 1)

    def test_match_lookup_human_id(self):
        '''
        Test match lookup by human id
        '''

        for h in self.human:
            m = match_lookup(h)
            self.assertTrue(len(m) == 1)

    def test_match_lookup_combined(self):
        '''
        Test match lookup by human id
        '''

        for h in self.combined:
            m = match_lookup(h)
            self.assertTrue(len(m) == 1)

    def test_match_lookup_collisions(self):
        '''
        Test match lookup handles collisions
        '''

        m = match_lookup(self.collision_hash)
        self.assertTrue(len(m) == 2)

        m = match_lookup(self.collision_human)
        self.assertTrue(len(m) == 2)

    def test_match_lookup_nonexistent(self):
        '''
        Test match lookup handles empty input
        '''

        m = match_lookup('')
        self.assertEqual(m, None)

    def test_match_get_problem_simple(self):
        '''
        Test that match_get_problem matches unique pattern
        '''

        p = match_get_problem('polkitd')
        self.assertEqual(p.component, 'polkitd')

    def test_match_get_problem_last(self):
        '''
        Test that match_get_problem matches last problem
        '''

        p = match_get_problem('last')
        self.assertEqual(p.uid, 1234)

    def test_match_get_problem_multiple(self):
        '''
        Test that match_get_problem fails when multiple problems match
        '''

        with captured_output() as (cap_stdout, cap_stderr):
            with self.assertRaises(SystemExit):
                match_get_problem('pavucontrol')

        stdout = cap_stdout.getvalue()
        self.assertIn("Ambiguous", stdout)
        self.assertIn("pavucontrol@bc60a5c", stdout)
        self.assertIn("pavucontrol@acbea5c", stdout)

    def test_match_get_problem_multiple_allowed(self):
        '''
        Test that match_get_problem matches multiple problems when allowed
        '''

        p = match_get_problem('pavucontrol', allow_multiple=True)
        self.assertEqual(len(p), 2)

    def test_match_get_problem_empty_database(self):
        '''
        Test that match_get_problem handles no problems in database
        '''

        import problem

        with clitests.monkey_patch(problem, 'list', lambda *args, **kwargs: []):
            with captured_output() as (cap_stdout, cap_stderr):
                with self.assertRaises(SystemExit):
                    match_get_problem('nope')

            stdout = cap_stdout.getvalue()
            self.assertIn("No problem(s) matched", stdout)

            # Similar with last
            with captured_output() as (cap_stdout, cap_stderr):
                with self.assertRaises(SystemExit):
                    match_get_problem('last')

            stdout = cap_stdout.getvalue()
            self.assertIn("No problems", stdout)

    def test_match_get_problem_nonexistent(self):
        '''
        Test that match_get_problem exits on non-existent problem
        '''

        with self.assertRaises(SystemExit):
            match_get_problem('nope')


if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    unittest.main()