# coding: utf-8
from __future__ import unicode_literals, division, absolute_import, print_function

import unittest
import sys
import os
from datetime import date, datetime, time, timedelta

from asn1crypto import util

from .unittest_data import data_decorator
from ._unittest_compat import patch

patch()

if sys.version_info < (3,):
    py2 = True
    byte_cls = str
    num_cls = long  # noqa
else:
    py2 = False
    byte_cls = bytes
    num_cls = int


tests_root = os.path.dirname(__file__)
fixtures_dir = os.path.join(tests_root, 'fixtures')
utc = util.timezone.utc


@data_decorator
class UtilTests(unittest.TestCase):

    def test_int_to_bytes(self):
        self.assertEqual(util.int_to_bytes(0, False, 0), b'')
        self.assertEqual(util.int_to_bytes(0, False), b'\x00')
        self.assertEqual(util.int_to_bytes(0, False, 3), b'\x00\x00\x00')
        self.assertEqual(util.int_to_bytes(0, True, 0), b'')
        self.assertEqual(util.int_to_bytes(0, True), b'\x00')
        self.assertEqual(util.int_to_bytes(0, True, 3), b'\x00\x00\x00')

        self.assertEqual(util.int_to_bytes(128, False), b'\x80')
        self.assertEqual(util.int_to_bytes(128, False, 3), b'\x00\x00\x80')
        self.assertEqual(util.int_to_bytes(-128, True), b'\x80')
        self.assertEqual(util.int_to_bytes(-128, True, 3), b'\xff\xff\x80')

        self.assertEqual(util.int_to_bytes(255, False), b'\xff')
        self.assertEqual(util.int_to_bytes(255, False, 3), b'\x00\x00\xff')
        self.assertEqual(util.int_to_bytes(-1, True), b'\xff')
        self.assertEqual(util.int_to_bytes(-1, True, 3), b'\xff\xff\xff')

        self.assertEqual(util.int_to_bytes(12345678, False), b'\xbc\x61\x4e')
        self.assertEqual(util.int_to_bytes(12345678, False, 3), b'\xbc\x61\x4e')
        self.assertEqual(util.int_to_bytes(12345678, False, 5), b'\x00\x00\xbc\x61\x4e')
        self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True), b'\xbc\x61\x4e')
        self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True, 3), b'\xbc\x61\x4e')
        self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True, 5), b'\xff\xff\xbc\x61\x4e')

        with self.assertRaises(OverflowError):
            util.int_to_bytes(123456789, width=3)
        with self.assertRaises(OverflowError):
            util.int_to_bytes(50000, signed=True, width=2)

    def test_int_from_bytes(self):
        self.assertEqual(util.int_from_bytes(b'', False), 0)
        self.assertEqual(util.int_from_bytes(b'', True), 0)
        self.assertEqual(util.int_from_bytes(b'\x00', False), 0)
        self.assertEqual(util.int_from_bytes(b'\x00', True), 0)
        self.assertEqual(util.int_from_bytes(b'\x80', False), 128)
        self.assertEqual(util.int_from_bytes(b'\x80', True), -128)
        self.assertEqual(util.int_from_bytes(b'\xff', False), 255)
        self.assertEqual(util.int_from_bytes(b'\xff', True), -1)
        self.assertEqual(util.int_from_bytes(b'\xbc\x61\x4e', False), 12345678)
        self.assertEqual(util.int_from_bytes(b'\xbc\x61\x4e', True), 12345678 - 2 ** 24)

    def test_int_fromto_bytes(self):
        for i in range(-300, 301):
            self.assertEqual(i, util.int_from_bytes(util.int_to_bytes(i, True), True))
        for i in range(0, 301):
            self.assertEqual(i, util.int_from_bytes(util.int_to_bytes(i, False), False))

    def test_timezone(self):
        delta_plus_5_42 = timedelta(hours=5, minutes=42)
        delta_minus_5_42 = -delta_plus_5_42

        # limited to +24h
        with self.assertRaises(ValueError):
            util.timezone(delta_plus_5_42 * 5)

        # limited to -24h
        with self.assertRaises(ValueError):
            util.timezone(delta_minus_5_42 * 5)

        # py2 implementation supports no sub-minutes time zones
        if py2:
            with self.assertRaises(ValueError):
                util.timezone(timedelta(hours=5, minutes=42, seconds=13))

            with self.assertRaises(ValueError):
                util.timezone(timedelta(hours=5, minutes=42, microseconds=13))

        # test __eq__
        tz0 = util.timezone(delta_plus_5_42)
        tz1 = util.timezone(delta_minus_5_42)
        self.assertEqual(tz0, tz0)
        self.assertEqual(tz1, tz1)
        self.assertNotEqual(tz0, tz1)
        self.assertFalse(tz0 == "not equal to a str")

        # test tzname
        self.assertEqual('5_42', util.timezone(delta_plus_5_42, '5_42').tzname(None))
        self.assertEqual('UTC+05:42', util.timezone(delta_plus_5_42).tzname(None))
        self.assertEqual('UTC-05:42', util.timezone(delta_minus_5_42).tzname(None))
        if py2 or sys.version_info >= (3, 6):
            # bpo22241
            self.assertEqual('UTC', util.timezone(timedelta(0)).tzname(None))

        # test utcoffset
        self.assertEqual(delta_minus_5_42, util.timezone(delta_minus_5_42).utcoffset(None))

        # test dst
        self.assertTrue(util.timezone(delta_minus_5_42).dst(None) in set((timedelta(0), None)))

        # test create_timezone
        self.assertTrue(util.create_timezone(delta_plus_5_42) is util.create_timezone(timedelta(hours=5, minutes=42)))
        self.assertFalse(util.create_timezone(delta_plus_5_42) is util.create_timezone(delta_minus_5_42))

    def test_utc_with_dst(self):
        self.assertEqual('UTC', util.utc_with_dst.tzname(None))

    def test_extended_date_strftime(self):
        self.assertEqual('0000-01-01', util.extended_date(0, 1, 1).strftime('%Y-%m-%d'))
        self.assertEqual('Sat Saturday Jan January', util.extended_date(0, 1, 1).strftime('%a %A %b %B'))
        self.assertEqual('Tue Tuesday Feb February 29', util.extended_date(0, 2, 29).strftime('%a %A %b %B %d'))
        if sys.platform == 'win32' and sys.version_info < (3, 5):
            self.assertEqual('01/01/00 00:00:00', util.extended_date(0, 1, 1).strftime('%c'))
        else:
            self.assertEqual('Sat Jan  1 00:00:00 0000', util.extended_date(0, 1, 1).strftime('%c'))
        self.assertEqual('01/01/00', util.extended_date(0, 1, 1).strftime('%x'))

    def test_extended_datetime_init(self):
        with self.assertRaises(ValueError):
            util.extended_datetime(2000, 11, 27)

    def test_extended_date_init(self):
        with self.assertRaises(ValueError):
            util.extended_date(2000, 11, 27)

    def test_extended_datetime_properties(self):
        zone = util.create_timezone(timedelta(hours=12, minutes=45))
        dt = util.extended_datetime(0, 11, 27, 5, 44, 31, 14889, zone)
        self.assertEqual(dt.year, 0)
        self.assertEqual(dt.month, 11)
        self.assertEqual(dt.day, 27)
        self.assertEqual(dt.hour, 5)
        self.assertEqual(dt.minute, 44)
        self.assertEqual(dt.second, 31)
        self.assertEqual(dt.microsecond, 14889)
        self.assertEqual(dt.tzinfo, zone)

    def test_extended_date_properties(self):
        ext_date = util.extended_date(0, 11, 27)
        self.assertEqual(ext_date.year, 0)
        self.assertEqual(ext_date.month, 11)
        self.assertEqual(ext_date.day, 27)

    def test_extended_datetime_isoformat(self):
        self.assertEqual('0000-01-01T00:00:00', util.extended_datetime(0, 1, 1).isoformat())
        self.assertEqual('0000-01-01T00:00:00.001000', util.extended_datetime(0, 1, 1, microsecond=1000).isoformat())
        self.assertEqual('0000-01-01%00:00:00', util.extended_datetime(0, 1, 1).isoformat(sep='%'))

    def test_extended_date_isoformat(self):
        self.assertEqual('0000-01-01', util.extended_date(0, 1, 1).isoformat())
        self.assertEqual('0000-11-27', util.extended_date(0, 11, 27).isoformat())

    def test_extended_datetime_strftime(self):
        self.assertEqual('0000-01-01 00:00:00', util.extended_datetime(0, 1, 1).strftime('%Y-%m-%d %H:%M:%S'))
        self.assertEqual('Sat Saturday Jan January', util.extended_datetime(0, 1, 1).strftime('%a %A %b %B'))
        self.assertEqual('Tue Tuesday Feb February 29', util.extended_datetime(0, 2, 29).strftime('%a %A %b %B %d'))
        if sys.platform == 'win32' and sys.version_info < (3, 5):
            self.assertEqual('01/01/00 00:00:00', util.extended_datetime(0, 1, 1).strftime('%c'))
        else:
            self.assertEqual('Sat Jan  1 00:00:00 0000', util.extended_datetime(0, 1, 1).strftime('%c'))
        self.assertEqual('01/01/00', util.extended_datetime(0, 1, 1).strftime('%x'))
        self.assertEqual('%Y', util.extended_datetime(0, 1, 1).strftime('%%Y'))

    def test_extended_datetime_replace(self):
        zone = util.create_timezone(timedelta(hours=12, minutes=45))
        ext_dt = util.extended_datetime(0, 1, 1, 23, tzinfo=zone)
        self.assertEqual(ext_dt.replace(year=2040, minute=59), datetime(2040, 1, 1, 23, 59, tzinfo=zone))
        self.assertEqual(ext_dt.replace(minute=59), util.extended_datetime(0, 1, 1, 23, 59, tzinfo=zone))

    def test_extended_date_replace(self):
        ext_date = util.extended_date(0, 2, 27)
        self.assertEqual(ext_date.replace(year=2040), date(2040, 2, 27))
        self.assertEqual(ext_date.replace(day=29), util.extended_date(0, 2, 29))
        with self.assertRaises(ValueError):
            ext_date.replace(day=30)

    def test_extended_datetime_encodings(self):
        zone = util.create_timezone(timedelta(hours=12, minutes=45))

        # test with microseconds
        ext_dt = util.extended_datetime(0, 2, 29, 9, 17, 45, 14889, zone)
        self.assertEqual(str(ext_dt), '0000-02-29 09:17:45.014889+12:45')
        if py2:
            self.assertEqual(unicode(ext_dt), '0000-02-29 09:17:45.014889+12:45')  # noqa: F821

        # test without microseconds
        ext_dt = util.extended_datetime(0, 2, 29, 9, 17, 45, 0, zone)
        self.assertEqual(str(ext_dt), '0000-02-29 09:17:45+12:45')
        if py2:
            self.assertEqual(unicode(ext_dt), '0000-02-29 09:17:45+12:45')  # noqa: F821

    def test_extended_date_encodings(self):
        ext_date = util.extended_date(0, 2, 29)
        self.assertEqual(str(ext_date), '0000-02-29')
        if py2:
            self.assertEqual(unicode(ext_date), '0000-02-29')  # noqa: F821

    def test_extended_datetime_timestamp(self):
        if sys.version_info >= (3, 3):
            zone = util.create_timezone(timedelta(hours=12, minutes=45))
            ext_dt = util.extended_datetime(0, 12, 31, 23, 0, 0, 14889, zone)
            dt = datetime(1, 1, 1, 0, 0, 0, 14889, zone)
            self.assertTrue(abs(dt.timestamp() - ext_dt.timestamp() - 3600.0) < 0.0000001)

    def test_extended_date_compare(self):
        self.assertTrue(util.extended_date(0, 1, 1) < date(1, 1, 1))
        self.assertTrue(util.extended_date(0, 1, 1) <= date(1, 1, 1))
        self.assertTrue(util.extended_date(0, 1, 1) != date(1, 1, 1))
        self.assertFalse(util.extended_date(0, 1, 1) == date(1, 1, 1))
        self.assertFalse(util.extended_date(0, 1, 1) >= date(1, 1, 1))
        self.assertFalse(util.extended_date(0, 1, 1) > date(1, 1, 1))

        self.assertFalse(util.extended_date(0, 1, 1) < util.extended_date(0, 1, 1))
        self.assertTrue(util.extended_date(0, 1, 1) <= util.extended_date(0, 1, 1))
        self.assertFalse(util.extended_date(0, 1, 1) != util.extended_date(0, 1, 1))
        self.assertTrue(util.extended_date(0, 1, 1) == util.extended_date(0, 1, 1))
        self.assertTrue(util.extended_date(0, 1, 1) >= util.extended_date(0, 1, 1))
        self.assertFalse(util.extended_date(0, 1, 1) > util.extended_date(0, 1, 1))

        self.assertTrue(util.extended_date(0, 1, 1) < util.extended_date(0, 1, 2))
        self.assertTrue(util.extended_date(0, 1, 1) <= util.extended_date(0, 1, 2))
        self.assertTrue(util.extended_date(0, 1, 1) != util.extended_date(0, 1, 2))
        self.assertFalse(util.extended_date(0, 1, 1) == util.extended_date(0, 1, 2))
        self.assertFalse(util.extended_date(0, 1, 1) >= util.extended_date(0, 1, 2))
        self.assertFalse(util.extended_date(0, 1, 1) > util.extended_date(0, 1, 2))

        self.assertFalse(util.extended_date(0, 1, 3) < util.extended_date(0, 1, 2))
        self.assertFalse(util.extended_date(0, 1, 3) <= util.extended_date(0, 1, 2))
        self.assertTrue(util.extended_date(0, 1, 3) != util.extended_date(0, 1, 2))
        self.assertFalse(util.extended_date(0, 1, 3) == util.extended_date(0, 1, 2))
        self.assertTrue(util.extended_date(0, 1, 3) >= util.extended_date(0, 1, 2))
        self.assertTrue(util.extended_date(0, 1, 3) > util.extended_date(0, 1, 2))

        with self.assertRaises(TypeError):
            util.extended_date(0, 1, 1) < "0000-01-02"

    def test_extended_datetime_compare(self):
        self.assertTrue(util.extended_datetime(0, 1, 1) < datetime(1, 1, 1))
        self.assertTrue(util.extended_datetime(0, 1, 1) <= datetime(1, 1, 1))
        self.assertTrue(util.extended_datetime(0, 1, 1) != datetime(1, 1, 1))
        self.assertFalse(util.extended_datetime(0, 1, 1) == datetime(1, 1, 1))
        self.assertFalse(util.extended_datetime(0, 1, 1) >= datetime(1, 1, 1))
        self.assertFalse(util.extended_datetime(0, 1, 1) > datetime(1, 1, 1))

        self.assertFalse(util.extended_datetime(0, 1, 1) < util.extended_datetime(0, 1, 1))
        self.assertTrue(util.extended_datetime(0, 1, 1) <= util.extended_datetime(0, 1, 1))
        self.assertFalse(util.extended_datetime(0, 1, 1) != util.extended_datetime(0, 1, 1))
        self.assertTrue(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 1))
        self.assertTrue(util.extended_datetime(0, 1, 1) >= util.extended_datetime(0, 1, 1))
        self.assertFalse(util.extended_datetime(0, 1, 1) > util.extended_datetime(0, 1, 1))

        self.assertTrue(util.extended_datetime(0, 1, 1) < util.extended_datetime(0, 1, 2))
        self.assertTrue(util.extended_datetime(0, 1, 1) <= util.extended_datetime(0, 1, 2))
        self.assertTrue(util.extended_datetime(0, 1, 1) != util.extended_datetime(0, 1, 2))
        self.assertFalse(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 2))
        self.assertFalse(util.extended_datetime(0, 1, 1) >= util.extended_datetime(0, 1, 2))
        self.assertFalse(util.extended_datetime(0, 1, 1) > util.extended_datetime(0, 1, 2))

        self.assertFalse(util.extended_datetime(0, 1, 3) < util.extended_datetime(0, 1, 2))
        self.assertFalse(util.extended_datetime(0, 1, 3) <= util.extended_datetime(0, 1, 2))
        self.assertTrue(util.extended_datetime(0, 1, 3) != util.extended_datetime(0, 1, 2))
        self.assertFalse(util.extended_datetime(0, 1, 3) == util.extended_datetime(0, 1, 2))
        self.assertTrue(util.extended_datetime(0, 1, 3) >= util.extended_datetime(0, 1, 2))
        self.assertTrue(util.extended_datetime(0, 1, 3) > util.extended_datetime(0, 1, 2))
        self.assertTrue(
            util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-8)))
            == datetime(1, 1, 1, 5, 4, 5, 6, utc)
        )
        self.assertTrue(
            util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-8)))
            == datetime(1, 1, 1, 5, 7, 5, 6, util.create_timezone(timedelta(hours=0, minutes=3)))
        )
        self.assertFalse(
            util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-7)))
            == datetime(1, 1, 1, 5, 4, 5, 6, utc)
        )
        self.assertFalse(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 1, tzinfo=utc))
        self.assertFalse(util.extended_datetime(0, 1, 1) == "0000-01-01")

        with self.assertRaises(TypeError):
            util.extended_datetime(0, 1, 1) < "0000-01-02"

    def test_extended_datetime_arithmetic(self):
        zone = util.create_timezone(timedelta(hours=12, minutes=45))
        ext_dt = util.extended_datetime(0, 12, 31, 9, 17, 45, 14889, zone)
        self.assertEqual(ext_dt + timedelta(hours=20), datetime(1, 1, 1, 5, 17, 45, 14889, zone))
        self.assertEqual(ext_dt - timedelta(hours=20), util.extended_datetime(0, 12, 30, 13, 17, 45, 14889, zone))
        self.assertEqual(ext_dt - ext_dt, timedelta(0))

        zone2 = util.create_timezone(timedelta(hours=-8, minutes=-31))
        ext_dt2 = util.extended_datetime(0, 11, 14, 13, 44, 20, 876543, zone2)
        expected_diff = timedelta(days=47, hours=-4, minutes=-27, seconds=25, microseconds=-861654)
        expected_diff -= timedelta(hours=20, minutes=76)
        self.assertEqual(ext_dt - ext_dt2, expected_diff)

        dt = datetime(400, 12, 31, 9, 17, 45, 14889, zone)
        self.assertEqual(dt - ext_dt, timedelta(days=util.extended_datetime.DAYS_IN_400_YEARS))
        self.assertEqual(ext_dt - dt, -timedelta(days=util.extended_datetime.DAYS_IN_400_YEARS))

        with self.assertRaises(TypeError):
            ext_dt - "test"

    def test_extended_datetime_compare_tzinfo(self):
        with self.assertRaises(TypeError):
            self.assertTrue(util.extended_datetime(0, 1, 1, tzinfo=utc) < datetime(1, 1, 1))
        with self.assertRaises(TypeError):
            self.assertTrue(util.extended_datetime(0, 1, 1) < datetime(1, 1, 1, tzinfo=utc))

    def test_extended_datetime_date_time(self):
        self.assertEqual(util.extended_date(0, 1, 1), util.extended_datetime(0, 1, 1).date())
        self.assertEqual(util.extended_date(0, 2, 29), util.extended_datetime(0, 2, 29).date())
        self.assertEqual(time(0, 0, 0), util.extended_datetime(0, 1, 1).time())

    def test_iri_to_uri(self):
        self.assertEqual(
            b'ldap://ldap.e-szigno.hu/CN=Microsec%20e-Szigno%20Root%20CA,OU=e-Szigno%20CA,'
            b'O=Microsec%20Ltd.,L=Budapest,C=HU?certificateRevocationList;binary',
            util.iri_to_uri(
                'ldap://ldap.e-szigno.hu/CN=Microsec e-Szigno Root CA,'
                'OU=e-Szigno CA,O=Microsec Ltd.,L=Budapest,C=HU?certificateRevocationList;binary'
            )
        )
        self.assertEqual(
            b'ldap://directory.d-trust.net/CN=D-TRUST%20Root%20Class%203%20CA%202%202009,'
            b'O=D-Trust%20GmbH,C=DE?certificaterevocationlist',
            util.iri_to_uri(
                'ldap://directory.d-trust.net/CN=D-TRUST Root Class 3 CA 2 2009,'
                'O=D-Trust GmbH,C=DE?certificaterevocationlist'
            )
        )
        self.assertEqual(
            b'ldap://directory.d-trust.net/CN=D-TRUST%20Root%20Class%203%20CA%202%20EV%202009,'
            b'O=D-Trust%20GmbH,C=DE?certificaterevocationlist',
            util.iri_to_uri(
                'ldap://directory.d-trust.net/CN=D-TRUST Root Class 3 CA 2 EV 2009,'
                'O=D-Trust GmbH,C=DE?certificaterevocationlist'
            )
        )