import os

import mock

import time

import shutil

import tempfile

import datetime

from kallithea.lib.vcs.utils.compat import unittest

from kallithea.lib.vcs.utils.paths import get_dirs_for_path

from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.helpers import get_scms_for_path

from kallithea.lib.vcs.utils.helpers import get_total_seconds

from kallithea.lib.vcs.utils.helpers import parse_changesets

from kallithea.lib.vcs.utils.helpers import parse_datetime

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.lib.vcs.utils.paths import get_user_home

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_GIT_REPO, TEST_TMP_PATH

class PathsTest(unittest.TestCase):

    def _test_get_dirs_for_path(self, path, expected):

        """

        Tests if get_dirs_for_path returns same as expected.

        """

        expected = sorted(expected)

        result = sorted(get_dirs_for_path(path))

        self.assertEqual(result, expected,

            msg="%s != %s which was expected result for path %s"

            % (result, expected, path))

    def test_get_dirs_for_path(self):

        path = 'foo/bar/baz/file'

        paths_and_results = (

            ('foo/bar/baz/file', ['foo', 'foo/bar', 'foo/bar/baz']),

            ('foo/bar/', ['foo', 'foo/bar']),

            ('foo/bar', ['foo']),

        )

        for path, expected in paths_and_results:

            self._test_get_dirs_for_path(path, expected)

    def test_get_scm(self):

        self.assertEqual(('hg', TEST_HG_REPO), get_scm(TEST_HG_REPO))

        self.assertEqual(('git', TEST_GIT_REPO), get_scm(TEST_GIT_REPO))

        timestamp = datetime.datetime.today() - datetime.timedelta(days=3)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        self.assertEqual(parse_datetime('3d'), expected)

        self.assertEqual(parse_datetime('3 d'), expected)

        self.assertEqual(parse_datetime('3 day'), expected)

        self.assertEqual(parse_datetime('3 days'), expected)

    def test_weeks(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        self.assertEqual(parse_datetime('3w'), expected)

        self.assertEqual(parse_datetime('3 w'), expected)

        self.assertEqual(parse_datetime('3 week'), expected)

        self.assertEqual(parse_datetime('3 weeks'), expected)

    def test_mixed(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        self.assertEqual(parse_datetime('2w3d'), expected)

        self.assertEqual(parse_datetime('2w 3d'), expected)

        self.assertEqual(parse_datetime('2w 3 days'), expected)

        self.assertEqual(parse_datetime('2 weeks 3 days'), expected)

class TestAuthorExtractors(unittest.TestCase):

    TEST_AUTHORS = [("Username Last'o'Name <username@example.com>",

                    ("Username Last'o'Name", "username@example.com")),

                  ("Username Last'o'Name Spaces < username@example.com >",

                    ("Username Last'o'Name Spaces", "username@example.com")),

                  ("Username Last'o'Name <username.lastname@example.com>",

                    ("Username Last'o'Name", "username.lastname@example.com")),

                  ('mrf RFC_SPEC <username+lastname@example.com>',

                    ('mrf RFC_SPEC', 'username+lastname@example.com')),

                  ('username <user@example.com>',

                    ('username', 'user@example.com')),

                  ('username <user@example.com',

                   ('username', 'user@example.com')),

                  ('broken missing@example.com',

                   ('broken', 'missing@example.com')),

                  ('<justemail@example.com>',

                   ('', 'justemail@example.com')),

                  ('justname',

                   ('justname', '')),

                  ('Mr Double Name withemail@example.com ',

                   ('Mr Double Name', 'withemail@example.com')),

                  ]

    def test_author_email(self):

        for test_str, result in self.TEST_AUTHORS:

            self.assertEqual(result[1], author_email(test_str))

    def test_author_name(self):

        for test_str, result in self.TEST_AUTHORS:

            self.assertEqual(result[0], author_name(test_str))

class TestGetDictForAttrs(unittest.TestCase):

    def test_returned_dict_has_expected_attrs(self):

        obj = mock.Mock()

        obj.NOT_INCLUDED = 'this key/value should not be included'

        obj.CONST = True

        obj.foo = 'aaa'

        obj.attrs = {'foo': 'bar'}

        obj.date = datetime.datetime(2010, 12, 31)

        obj.count = 1001

        self.assertEqual(get_dict_for_attrs(obj, ['CONST', 'foo', 'attrs',

            'date', 'count']), {

            'CONST': True,

            'foo': 'aaa',

            'attrs': {'foo': 'bar'},

            'date': datetime.datetime(2010, 12, 31),

            'count': 1001,

        })

class TestGetTotalSeconds(unittest.TestCase):

    def assertTotalSecondsEqual(self, timedelta, expected_seconds):

        result = get_total_seconds(timedelta)

        self.assertEqual(result, expected_seconds,

            "We computed %s seconds for %s but expected %s"

            % (result, timedelta, expected_seconds))

    def test_get_total_seconds_returns_proper_value(self):

        self.assertTotalSecondsEqual(datetime.timedelta(seconds=1001), 1001)

    def test_get_total_seconds_returns_proper_value_for_partial_seconds(self):

        self.assertTotalSecondsEqual(datetime.timedelta(seconds=50.65), 50.65)