# Test methods with long descriptive names can omit docstrings
# pylint: disable=missing-docstring
# pylint: disable=protected-access
import csv
import os
import sys
import math
import unittest
import pickle
import pkgutil
import warnings
from datetime import datetime, timezone

from tempfile import NamedTemporaryFile, TemporaryDirectory

import numpy as np
import pandas as pd
import scipy.sparse as sp

from Orange.data import Variable, ContinuousVariable, DiscreteVariable, \
    StringVariable, TimeVariable, Unknown, Value, Table
from Orange.data.io import CSVReader
from Orange.preprocess.transformation import Identity
from Orange.tests.base import create_pickling_tests
from Orange.util import OrangeDeprecationWarning


def is_on_path(name):
    """
    Is a top level package/module found on sys.path

    Parameters
    ----------
    name : str
        Top level module/package name

    Returns
    -------
    found : bool
    """
    for _, name_, _ in pkgutil.iter_modules(sys.path):
        if name == name_:
            return True
    return False


# noinspection PyPep8Naming,PyUnresolvedReferences
class VariableTest:
    def test_dont_pickle_anonymous_variables(self):
        with self.assertWarns(OrangeDeprecationWarning):
            self.assertRaises(pickle.PickleError, pickle.dumps, self.varcls())

    def test_dont_make_anonymous_variables(self):
        self.assertWarns(OrangeDeprecationWarning, self.varcls.make, "")

    def test_copy_copies_attributes(self):
        var = self.varcls("x")
        var.attributes["a"] = "b"
        var2 = var.copy(compute_value=None)
        self.assertIn("a", var2.attributes)
        self.assertIsInstance(var2, type(var))

        var2.attributes["a"] = "c"
        # Attributes of original value should not change
        self.assertEqual(var.attributes["a"], "b")

    def test_rename(self):
        var = self.varcls_modified("x")
        var2 = var.copy(name="x2")
        self.assertIsInstance(var2, type(var))
        self.assertIsNot(var, var2)
        self.assertEqual(var2.name, "x2")
        var.__dict__.pop("_name")
        var2.__dict__.pop("_name")
        self.assertDictEqual(var.__dict__, var2.__dict__)

    def varcls_modified(self, name):
        var = self.varcls(name)
        var._compute_value = lambda x: x
        var.sparse = True
        var.attributes = {"a": 1}
        return var


class TestVariable(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.var = Variable("x")

    def test_name(self):
        self.assertEqual(repr(self.var), "Variable(name='x')")

    def test_to_val(self):
        string_var = StringVariable("x")
        self.assertEqual(string_var.to_val("foo"), "foo")
        self.assertEqual(string_var.to_val(42), "42")

        cont_var = ContinuousVariable("x")
        self.assertTrue(math.isnan(cont_var.to_val("?")))
        self.assertTrue(math.isnan(Unknown))

        var = Variable("x")
        self.assertEqual(var.to_val("x"), "x")

    def test_repr_is_abstract(self):
        self.assertRaises(RuntimeError, self.var.repr_val, None)

    def test_properties(self):
        a = ContinuousVariable("y")
        self.assertTrue(a.is_continuous)
        self.assertFalse(a.is_discrete)
        self.assertFalse(a.is_string)
        self.assertTrue(a.is_primitive())

        a = DiscreteVariable("d")
        self.assertFalse(a.is_continuous)
        self.assertTrue(a.is_discrete)
        self.assertFalse(a.is_string)
        self.assertTrue(a.is_primitive())

        a = StringVariable("s")
        self.assertFalse(a.is_continuous)
        self.assertFalse(a.is_discrete)
        self.assertTrue(a.is_string)
        self.assertFalse(a.is_primitive())

    def test_properties_as_predicates(self):
        a = ContinuousVariable("y")
        self.assertTrue(Variable.is_continuous(a))
        self.assertFalse(Variable.is_discrete(a))
        self.assertFalse(Variable.is_string(a))
        self.assertTrue(Variable.is_primitive(a))

        a = StringVariable("s")
        self.assertFalse(Variable.is_continuous(a))
        self.assertFalse(Variable.is_discrete(a))
        self.assertTrue(Variable.is_string(a))
        self.assertFalse(Variable.is_primitive(a))

    def test_strange_eq(self):
        a = ContinuousVariable("a")
        b = ContinuousVariable("a")
        self.assertEqual(a, a)
        self.assertEqual(a, b)
        self.assertIsNot(a, b)
        self.assertNotEqual(a, "somestring")
        self.assertEqual(hash(a), hash(b))

    def test_eq_with_compute_value(self):
        a = ContinuousVariable("a")
        b = ContinuousVariable("a")
        self.assertEqual(a, a)
        self.assertEqual(a, b)
        self.assertIsNot(a, b)

        a._compute_value = lambda x: x
        self.assertEqual(a, a)
        self.assertNotEqual(a, b)

        a1 = ContinuousVariable("a")
        a2 = ContinuousVariable("a")
        c = ContinuousVariable("c")

        a._compute_value = Identity(a1)
        self.assertEqual(a, a)
        self.assertEqual(a, b)
        self.assertEqual(hash(a), hash(b))

        b._compute_value = a.compute_value
        self.assertEqual(a, b)

        b._compute_value = Identity(a1)
        self.assertEqual(a, b)

        b._compute_value = Identity(a2)
        self.assertEqual(a, b)

        b._compute_value = Identity(c)
        self.assertNotEqual(a, b)

        b._compute_value = Identity(a2)
        a1._compute_value = lambda x: x
        self.assertNotEqual(a, b)

        a1._compute_value = Identity(c)
        self.assertNotEqual(a, b)

        a2._compute_value = Identity(c)
        self.assertEqual(a, b)

    def test_hash(self):
        a = ContinuousVariable("a")
        b = ContinuousVariable("a")
        self.assertEqual(hash(a), hash(b))

        a._compute_value = lambda x: x
        self.assertNotEqual(hash(a), hash(b))

        b._compute_value = lambda x: x
        self.assertNotEqual(hash(a), hash(b))

        a1 = ContinuousVariable("a")
        a2 = ContinuousVariable("a")

        a._compute_value = Identity(a1)
        self.assertNotEqual(hash(a), hash(b))

        b._compute_value = Identity(a2)
        self.assertEqual(hash(a), hash(b))

        at = TimeVariable("a")
        b = ContinuousVariable("b")
        self.assertEqual(hash(a1), hash(a2))
        self.assertNotEqual(hash(a1), hash(b))
        self.assertNotEqual(hash(a1), hash(at))

    def test_hash_eq(self):
        a = ContinuousVariable("a")
        a1 = ContinuousVariable("a")
        b1 = ContinuousVariable("b", compute_value=Identity(a))
        b2 = ContinuousVariable("b2", compute_value=Identity(b1))
        b3 = ContinuousVariable("b")
        c1 = ContinuousVariable("c", compute_value=Identity(a))
        c2 = ContinuousVariable("c", compute_value=Identity(a))
        self.assertNotEqual(a, b2)
        self.assertNotEqual(b1, b2)
        self.assertNotEqual(a, b1)
        self.assertNotEqual(b1, b3)
        self.assertEqual(a, a1)
        self.assertEqual(c1, c2)

        self.assertNotEqual(hash(a), hash(b2))
        self.assertNotEqual(hash(b1), hash(b2))
        self.assertNotEqual(hash(a), hash(b1))
        self.assertNotEqual(hash(b1), hash(b3))
        self.assertEqual(hash(a), hash(a1))
        self.assertEqual(hash(c1), hash(c2))

    def test_compute_value_eq_warning(self):
        with warnings.catch_warnings(record=True) as warns:
            ContinuousVariable("x")
            self.assertEqual(warns, [])
            ContinuousVariable("x", compute_value=lambda *_: 42)
            self.assertEqual(warns, [])

            class Valid:
                def __eq__(self, other):
                    return self is other

                def __hash__(self):
                    return super().__hash__(self)

            ContinuousVariable("x", compute_value=Valid())
            self.assertEqual(warns, [])

            class AlsoValid:
                InheritEq = True

            ContinuousVariable("x", compute_value=AlsoValid())
            self.assertEqual(warns, [])

            class Invalid:
                pass

            ContinuousVariable("x", compute_value=Invalid())
            self.assertNotEqual(warns, [])

        with warnings.catch_warnings(record=True) as warns:

            class InheritEqInherited(AlsoValid):
                pass

            ContinuousVariable("x", compute_value=InheritEqInherited())
            self.assertNotEqual(warns, [])

        with warnings.catch_warnings(record=True) as warns:

            class MissingHash:
                def __eq__(self, other):
                    return self is other

            ContinuousVariable("x", compute_value=MissingHash())
            self.assertNotEqual(warns, [])

        with warnings.catch_warnings(record=True) as warns:

            class MissingEq:
                def __hash__(self):
                    return super().__hash__(self)

            ContinuousVariable("x", compute_value=MissingEq())
            self.assertNotEqual(warns, [])


def variabletest(varcls):
    def decorate(cls):
        return type(cls.__name__, (cls, unittest.TestCase), {'varcls': varcls})
    return decorate


@variabletest(DiscreteVariable)
class TestDiscreteVariable(VariableTest):
    def test_to_val(self):
        values = ["F", "M"]
        var = DiscreteVariable(name="Feature 0", values=values)

        self.assertEqual(var.to_val(0), 0)
        self.assertEqual(var.to_val("F"), 0)
        self.assertEqual(var.to_val(0.), 0)
        self.assertTrue(math.isnan(var.to_val("?")))

        # TODO: with self.assertRaises(ValueError): var.to_val(2)
        with self.assertRaises(ValueError):
            var.to_val("G")

    def test_make(self):
        var = DiscreteVariable.make("a", values=("F", "M"))
        self.assertIsInstance(var, DiscreteVariable)
        self.assertEqual(var.name, "a")
        self.assertEqual(var.values, ("F", "M"))

    def test_val_from_str(self):
        var = DiscreteVariable.make("a", values=("F", "M"))
        self.assertTrue(math.isnan(var.to_val(None)))
        self.assertEqual(var.to_val(1), 1)

    def test_val_from_str_add(self):
        var = DiscreteVariable.make("a", values=("F", "M"))
        self.assertTrue(math.isnan(var.val_from_str_add(None)))
        self.assertEqual(var.val_from_str_add("M"), 1)
        self.assertEqual(var.val_from_str_add("F"), 0)
        self.assertEqual(var.values, ("F", "M"))
        self.assertEqual(var.val_from_str_add("N"), 2)
        self.assertEqual(var.values, ("F", "M", "N"))
        self.assertEqual(var._value_index, {"F": 0, "M": 1, "N": 2})
        self.assertEqual(var.val_from_str_add("M"), 1)
        self.assertEqual(var.val_from_str_add("F"), 0)
        self.assertEqual(var.val_from_str_add("N"), 2)

    def test_repr(self):
        var = DiscreteVariable.make("a", values=("F", "M"))
        self.assertEqual(
            repr(var),
            "DiscreteVariable(name='a', values=('F', 'M'))")

        var = DiscreteVariable.make("a", values="1234567")
        self.assertEqual(
            repr(var),
            "DiscreteVariable(name='a', values=('1', '2', '3', '4', '5', '6', '7'))"
        )

    def test_no_nonstringvalues(self):
        self.assertRaises(TypeError, DiscreteVariable, "foo", values=("a", 42))
        a = DiscreteVariable("foo", values=("a", "b", "c"))
        self.assertRaises(TypeError, a.add_value, 42)

    def test_no_duplicated_values(self):
        a = DiscreteVariable("foo", values=["a", "b", "c"])
        a.add_value("b")
        self.assertEqual(list(a.values), ["a", "b", "c"])
        self.assertEqual(list(a._value_index), ["a", "b", "c"])

    def test_no_duplicates_in_constructor(self):
        self.assertRaises(ValueError, DiscreteVariable,
                          "foo", values=("a", "b", "a"))

    def test_unpickle(self):
        d1 = DiscreteVariable("A", values=("two", "one"))
        s = pickle.dumps(d1)
        d2 = DiscreteVariable.make("A", values=("one", "two", "three"))
        d2_values = tuple(d2.values)
        d1c = pickle.loads(s)
        # See: gh-3238
        # The unpickle reconstruction picks an existing variable (d2), on which
        # __setstate__ or __dict__.update is called
        self.assertSequenceEqual(d2.values, d2_values)
        self.assertSequenceEqual(d1c.values, d1.values)
        s = pickle.dumps(d2)
        d1 = DiscreteVariable("A", values=("one", "two"))
        d2 = pickle.loads(s)
        self.assertSequenceEqual(d2.values, ("one", "two", "three"))
        self.assertSequenceEqual(d1.values, ("one", "two"))

    def test_mapper_dense(self):
        abc = DiscreteVariable("a", values=tuple("abc"))
        dca = DiscreteVariable("a", values=tuple("dca"))
        mapper = dca.get_mapper_from(abc)

        self.assertEqual(mapper(0), 2)
        self.assertTrue(np.isnan(mapper(1)))
        self.assertEqual(mapper(2), 1)

        self.assertEqual(mapper(0.), 2)
        self.assertTrue(np.isnan(mapper(1.)))
        self.assertEqual(mapper(2.), 1)
        self.assertTrue(np.isnan(mapper(np.nan)))

        self.assertEqual(mapper("a"), 2)
        self.assertTrue(np.isnan(mapper("b")))
        self.assertEqual(mapper("c"), 1)

        arr = np.array([0, 0, 2, 1, 0, 1, np.nan])
        self.assertIsNot(mapper(arr), arr)
        np.testing.assert_array_equal(
            mapper(arr), np.array([2, 2, 1, np.nan, 2, np.nan, np.nan]))
        # dtype=int can have no nans; isnan shouldn't crash the mapper

        arr_int = arr[:-1].astype(int)
        self.assertIsNot(mapper(arr_int), arr_int)
        np.testing.assert_array_equal(
            mapper(arr_int), np.array([2, 2, 1, np.nan, 2, np.nan]))

        arr_obj = arr.astype(object)
        self.assertIsNot(mapper(arr_obj), arr_obj)
        np.testing.assert_array_equal(
            mapper(arr_obj), np.array([2, 2, 1, np.nan, 2, np.nan, np.nan]))

        arr_list = list(arr)
        self.assertIsNot(mapper(arr_list), arr_list)
        self.assertTrue(
            all(x == y or (np.isnan(x) and np.isnan(y))
                for x, y in zip(mapper(arr_list),
                                [2, 2, 1, np.nan, 2, np.nan, np.nan])))

        self.assertTrue(
            x == y or (np.isnan(x) and np.isnan(y))
            for x, y in zip(mapper(tuple(arr)),
                            (2, 2, 1, np.nan, 2, np.nan, np.nan)))

        self.assertRaises(ValueError, mapper, object())

    def test_mapper_sparse(self):
        abc = DiscreteVariable("a", values=tuple("abc"))
        dca = DiscreteVariable("a", values=tuple("dca"))
        mapper = dca.get_mapper_from(abc)

        arr = np.array([0, 0, 2, 1, 0, 1, np.nan])

        # 0 does map to 0 -> convert to dense
        marr = mapper(sp.csr_matrix(arr))
        self.assertIsInstance(marr, np.ndarray)
        np.testing.assert_array_equal(
            marr,
            np.array([2, 2, 1, np.nan, 2, np.nan, np.nan]))

        marr = mapper(sp.csr_matrix(arr))
        self.assertIsInstance(marr, np.ndarray)
        np.testing.assert_array_equal(
            marr,
            np.array([2, 2, 1, np.nan, 2, np.nan, np.nan]))

        # 0 maps to 0 -> keep sparse
        acd = DiscreteVariable("a", values=tuple("acd"))
        mapper = acd.get_mapper_from(abc)

        arr_csr = sp.csr_matrix(arr)
        marr = mapper(arr_csr)
        self.assertIsNot(arr_csr, marr)
        self.assertTrue(sp.isspmatrix_csr(marr))
        np.testing.assert_array_equal(
            marr.todense(),
            np.array([[0, 0, 1, np.nan, 0, np.nan, np.nan]]))

        arr_csc = sp.csc_matrix(arr)
        marr = mapper(arr_csc)
        self.assertIsNot(arr_csc, marr)
        self.assertTrue(sp.isspmatrix_csc(marr))
        np.testing.assert_array_equal(
            marr.todense(),
            np.array([[0, 0, 1, np.nan, 0, np.nan, np.nan]]))

    def test_mapper_inplace(self):
        s = list(range(7))
        abc = DiscreteVariable("a", values=tuple("abc"))
        dca = DiscreteVariable("a", values=tuple("dca"))
        mapper = dca.get_mapper_from(abc)

        arr = np.array([[0, 0, 2, 1, 0, 1, np.nan], s]).T
        mapper(arr, 0)
        np.testing.assert_array_equal(
            arr, np.array([[2, 2, 1, np.nan, 2, np.nan, np.nan], s]).T)

        self.assertRaises(ValueError, mapper, sp.csr_matrix(arr), 0)
        self.assertRaises(ValueError, mapper, [1, 2, 3], 0)
        self.assertRaises(ValueError, mapper, 1, 0)

        acd = DiscreteVariable("a", values=tuple("acd"))
        mapper = acd.get_mapper_from(abc)

        arr = np.array([[0, 0, 2, 1, 0, 1, np.nan], s]).T
        mapper(arr, 0)
        np.testing.assert_array_equal(
            arr, np.array([[0, 0, 1, np.nan, 0, np.nan, np.nan], s]).T)

        arr = sp.csr_matrix(np.array([[0, 0, 2, 1, 0, 1, np.nan], s]).T)
        mapper(arr, 0)
        np.testing.assert_array_equal(
            arr.todense(),
            np.array([[0, 0, 1, np.nan, 0, np.nan, np.nan], s]).T)

        arr = sp.csc_matrix(np.array([[0, 0, 2, 1, 0, 1, np.nan], s]).T)
        mapper(arr, 0)
        np.testing.assert_array_equal(
            arr.todense(),
            np.array([[0, 0, 1, np.nan, 0, np.nan, np.nan], s]).T)

    def test_mapper_dim_check(self):
        abc = DiscreteVariable("a", values=tuple("abc"))
        dca = DiscreteVariable("a", values=tuple("dca"))
        mapper = dca.get_mapper_from(abc)

        self.assertRaises(ValueError, mapper, np.zeros((7, 2)))
        self.assertRaises(ValueError, mapper, sp.csr_matrix(np.zeros((7, 2))))
        self.assertRaises(ValueError, mapper, sp.csc_matrix(np.zeros((7, 2))))

    def test_mapper_from_no_values(self):
        abc = DiscreteVariable("a", values=())
        dca = DiscreteVariable("a", values=tuple("dca"))
        mapper = dca.get_mapper_from(abc)

        arr = np.full(7, np.nan)
        self.assertIsNot(mapper(arr), arr)
        np.testing.assert_array_equal(mapper(arr), arr)

        arr_csr = sp.csr_matrix(arr)
        self.assertIsNot(arr_csr, mapper(arr_csr))
        np.testing.assert_array_equal(
            mapper(arr_csr).todense(), np.atleast_2d(arr))

        arr_csc = sp.csc_matrix(arr)
        self.assertIsNot(arr_csc, mapper(arr_csc))
        np.testing.assert_array_equal(
            mapper(arr_csc).todense(), np.atleast_2d(arr))

        self.assertRaises(ValueError, mapper, sp.csr_matrix(arr), 0)
        self.assertRaises(ValueError, mapper, sp.csc_matrix(arr), 0)

    def varcls_modified(self, name):
        var = super().varcls_modified(name)
        var.add_value("A")
        var.add_value("B")
        return var

    def test_copy_checks_len_values(self):
        var = DiscreteVariable("gender", values=("F", "M"))
        self.assertEqual(var.values, ("F", "M"))

        self.assertRaises(ValueError, var.copy, values=("F", "M", "N"))
        self.assertRaises(ValueError, var.copy, values=("F",))
        self.assertRaises(ValueError, var.copy, values=())

        var2 = var.copy()
        self.assertEqual(var2.values, ("F", "M"))

        var2 = var.copy(values=None)
        self.assertEqual(var2.values, ("F", "M"))

        var2 = var.copy(values=("W", "M"))
        self.assertEqual(var2.values, ("W", "M"))

    def test_pickle_backward_compatibility(self):
        """
        Test that pickle made with an older version of Orange are correctly
        loaded after changes in DiscreteVariable
        """
        with warnings.catch_warnings():
            # travis/gh-action tests change OrangeDeprecationWarning to error
            # temporary disable it
            warnings.simplefilter('default', OrangeDeprecationWarning)
            this_dir = os.path.dirname(os.path.realpath(__file__))
            datasets_dir = os.path.join(
                this_dir, "..", "..", "tests", "datasets"
            )
            # pickle with values as list
            Table(os.path.join(datasets_dir, "sailing-orange-3-20.pkl"))
            # pickle with values as tuple list
            Table(os.path.join(datasets_dir, "iris-orange-3-25.pkl"))


@variabletest(ContinuousVariable)
class TestContinuousVariable(VariableTest):
    def test_make(self):
        age1 = ContinuousVariable.make("age")
        age2 = ContinuousVariable.make("age")
        self.assertEqual(age1, age2)
        self.assertIsNot(age1, age2)

    def test_decimals(self):
        a = ContinuousVariable("a", 4)
        self.assertEqual(a.str_val(4.6543), "4.6543")
        self.assertEqual(a.str_val(4.25), "4.2500")
        self.assertEqual(a.str_val(Unknown), "?")
        a = ContinuousVariable("a", 5)
        self.assertEqual(a.str_val(0.000000000001), "0.00000")
        a = ContinuousVariable("a", 10)
        self.assertEqual(a.str_val(0.000000000001), "1e-12")

    def test_more_decimals(self):
        a = ContinuousVariable("a", 0)
        self.assertEqual(a.str_val(4), "4")
        self.assertEqual(a.str_val(4.1234), "4.12")

        a = ContinuousVariable("a", 2)
        self.assertEqual(a.str_val(4), "4.00")
        self.assertEqual(a.str_val(4.25), "4.25")
        self.assertEqual(a.str_val(4.1234123), "4.1234")

        for cca4 in (4 + 1e-9, 4 - 1e-9):
            assert cca4 != 4
            self.assertEqual(a.str_val(cca4), "4.00")

    def test_adjust_decimals(self):
        # Default is 3 decimals, but format is %g
        a = ContinuousVariable("a")
        self.assertEqual(a.str_val(5), "5")
        self.assertEqual(a.str_val(4.65432), "4.65432")

        # Change to no decimals
        a.val_from_str_add("5")
        self.assertEqual(a.str_val(5), "5")

        # Change to two decimals
        a.val_from_str_add("  5.12    ")
        self.assertEqual(a.str_val(4.65), "4.65")
        self.assertEqual(a.str_val(5), "5.00")

    def varcls_modified(self, name):
        var = super().varcls_modified(name)
        var.number_of_decimals = 5
        return var


@variabletest(StringVariable)
class TestStringVariable(VariableTest):
    def test_val(self):
        a = StringVariable("a")
        self.assertEqual(a.to_val(None), "")
        self.assertEqual(a.str_val(""), "?")
        self.assertEqual(a.str_val(Value(a, "")), "?")
        self.assertEqual(a.repr_val(Value(a, "foo")), '"foo"')
        self.assertEqual(a.str_val(np.nan), "?")
        self.assertEqual(a.str_val(None), "?")


@variabletest(TimeVariable)
class TestTimeVariable(VariableTest):
    TESTS = [
        # in str, UTC timestamp, out str (in UTC)
        ('2015-10-12 14:13:11.01+0200', 1444651991.01, '2015-10-12 14:13:11.010000+0200'),
        ('2015-10-12T14:13:11.81+0200', 1444651991.81, '2015-10-12 14:13:11.810000+0200'),
        ('2015-10-12 14:13:11.81', 1444659191.81, '2015-10-12 14:13:11.810000'),
        ('2015-10-12T14:13:11.81', 1444659191.81, '2015-10-12 14:13:11.810000'),
        ('2015-10-12 14:13:11+0200', 1444651991, '2015-10-12 14:13:11+0200'),
        ('2015-10-12T14:13:11+0200', 1444651991, '2015-10-12 14:13:11+0200'),
        ('20151012T141311+0200', 1444651991, '2015-10-12 14:13:11+0200'),
        ('20151012141311+0200', 1444651991, '2015-10-12 14:13:11+0200'),
        ('2015-10-12 14:13:11', 1444659191, '2015-10-12 14:13:11'),
        ('2015-10-12T14:13:11', 1444659191, '2015-10-12 14:13:11'),
        ('2015-10-12 14:13', 1444659180, '2015-10-12 14:13:00'),
        ('20151012T141311', 1444659191, '2015-10-12 14:13:11'),
        ('20151012141311', 1444659191, '2015-10-12 14:13:11'),
        ('2015-10-12', 1444608000, '2015-10-12'),
        ('20151012', 1444608000, '2015-10-12'),
        ('2015-285', 1444608000, '2015-10-12'),
        ('2015-10', 1443657600, '2015-10-01'),
        ('2015', 1420070400, '2015-01-01'),
        ('01:01:01.01', 3661.01, '01:01:01.010000'),
        ('010101.01', 3661.01, '01:01:01.010000'),
        ('01:01:01', 3661, '01:01:01'),
        ('01:01', 3660, '01:01:00'),
        ('1970-01-01 00:00:00', 0, '1970-01-01 00:00:00'),
        ('1969-12-31 23:59:59', -1, '1969-12-31 23:59:59'),
        ('1969-12-31 23:59:58.9', -1.1, '1969-12-31 23:59:58.900000'),
        ('1900-01-01', -2208988800, '1900-01-01'),
        ('nan', np.nan, '?'),
        ('1444651991.81', 1444651991.81, '2015-10-12 12:13:11.810000'),
    ]

    def test_parse_repr(self):
        for datestr, timestamp, outstr in self.TESTS:
            var = TimeVariable('time')
            ts = var.to_val(datestr)  # calls parse for strings
            if not np.isnan(ts):
                self.assertEqual(ts, timestamp, msg=datestr)
            self.assertEqual(var.repr_val(ts), outstr, msg=datestr)

    def test_parse_utc(self):
        var = TimeVariable('time')
        datestr, offset = '2015-10-18 22:48:20', '+0200'
        ts1 = var.parse(datestr + offset)
        self.assertEqual(var.repr_val(ts1), datestr + offset)
        # Once a value is without a TZ, all the values lose it
        ts2 = var.parse(datestr)
        self.assertEqual(var.repr_val(ts2), datestr)
        self.assertEqual(var.repr_val(ts1), '2015-10-18 20:48:20')
        # TZ is reset to UTC.
        datestr, offset = '2015-10-18T22:48:20', '+02:00'
        ts3 = var.parse(datestr + offset)
        self.assertEqual(var.repr_val(ts3), '2015-10-18 20:48:20')

    def test_parse_timestamp(self):
        var = TimeVariable("time")
        datestr = str(datetime(2016, 6, 14, 23, 8, tzinfo=timezone.utc).timestamp())
        ts1 = var.parse(datestr)
        self.assertEqual(var.repr_val(ts1), '2016-06-14 23:08:00')

    def test_parse_invalid(self):
        var = TimeVariable('var')
        with self.assertRaises(ValueError):
            var.parse('123')

    def test_have_date(self):
        var = TimeVariable('time')
        ts = var.parse('1937-08-02')  # parse date
        self.assertEqual(var.repr_val(ts), '1937-08-02')
        ts = var.parse('16:20')  # parse time
        # observe have datetime
        self.assertEqual(var.repr_val(ts), '1970-01-01 16:20:00')

    def test_no_date_no_time(self):
        self.assertEqual(TimeVariable('relative time').repr_val(1.6), '1.6')

    def test_readwrite_timevariable(self):
        content = [
            ("Date", "Feature"),
            ("time", "continuous"),
            ("", ""),
            ("1920-12-12", 1.0),
            ("1920-12-13", 3.0),
            ("1920-12-14", 5.5),
        ]
        with NamedTemporaryFile(
            mode="w", delete=False, newline="", encoding="utf-8"
        ) as input_csv:
            csv.writer(input_csv, delimiter=",").writerows(content)

        table = CSVReader(input_csv.name).read()
        self.assertIsInstance(table.domain["Date"], TimeVariable)
        self.assertEqual(table[0, "Date"], "1920-12-12")
        # Dates before 1970 are negative
        self.assertTrue(all(inst["Date"] < 0 for inst in table))

        with NamedTemporaryFile(mode="w", delete=False) as output_csv:
            pass
        CSVReader.write_file(output_csv.name, table)

        with open(input_csv.name, encoding="utf-8") as in_f:
            with open(output_csv.name, encoding="utf-8") as out_f:
                self.assertEqual(in_f.read(), out_f.read())

        os.unlink(input_csv.name)
        os.unlink(output_csv.name)

    def test_repr_value(self):
        # https://github.com/biolab/orange3/pull/1760
        var = TimeVariable('time')
        self.assertEqual(var.repr_val(Value(var, 416.3)), '416.3')

    def test_repr_value_out_of_bounds(self):
        var = TimeVariable("T", have_date=True, have_time=True)
        self.assertEqual(var.repr_val(1e300), "?")
        self.assertEqual(var.repr_val(-1e300), "?")

    def test_have_date_have_time_in_construct(self):
        """Test if have_time and have_date is correctly set"""
        var = TimeVariable('time', have_date=1)
        self.assertTrue(var.have_date)
        self.assertFalse(var.have_time)

    def varcls_modified(self, name):
        var = super().varcls_modified(name)
        var.number_of_decimals = 5
        var.have_date = 1
        var.have_time = 1
        return var

    def test_additional_formats(self):
        expected_date = datetime(2022, 2, 7)
        dates = {
            "2021-11-25": ("2022-02-07",),
            "25.11.2021": ("07.02.2022", "07. 02. 2022", "7.2.2022", "7. 2. 2022"),
            "25.11.21": ("07.02.22", "07. 02. 22", "7.2.22", "7. 2. 22"),
            "11/25/2021": ("02/07/2022", "2/7/2022"),
            "11/25/21": ("02/07/22", "2/7/22"),
            "20211125": ("20220207",),
        }
        expected_date_time = datetime(2022, 2, 7, 10, 11, 12)
        date_times = {
            "2021-11-25 00:00:00": (
                "2022-02-07 10:11:12",
                "2022-02-07 10:11:12.00",
            ),
            "25.11.2021 00:00:00": (
                "07.02.2022 10:11:12",
                "07. 02. 2022 10:11:12",
                "7.2.2022 10:11:12",
                "7. 2. 2022 10:11:12",
                "07.02.2022 10:11:12.00",
                "07. 02. 2022 10:11:12.00",
                "7.2.2022 10:11:12.00",
                "7. 2. 2022 10:11:12.00",
            ),
            "25.11.21 00:00:00": (
                "07.02.22 10:11:12",
                "07. 02. 22 10:11:12",
                "7.2.22 10:11:12",
                "7. 2. 22 10:11:12",
                "07.02.22 10:11:12.00",
                "07. 02. 22 10:11:12.00",
                "7.2.22 10:11:12.00",
                "7. 2. 22 10:11:12.00",
            ),
            "11/25/2021 00:00:00": (
                "02/07/2022 10:11:12",
                "2/7/2022 10:11:12",
                "02/07/2022 10:11:12.00",
                "2/7/2022 10:11:12.00",
            ),
            "11/25/21 00:00:00": (
                "02/07/22 10:11:12",
                "2/7/22 10:11:12",
                "02/07/22 10:11:12.00",
                "2/7/22 10:11:12.00",
            ),
            "20211125000000": ("20220207101112", "20220207101112.00"),
        }
        # times without seconds
        expected_date_time2 = datetime(2022, 2, 7, 10, 11, 0)
        date_times2 = {
            "2021-11-25 00:00:00": ("2022-02-07 10:11",),
            "25.11.2021 00:00:00": (
                "07.02.2022 10:11",
                "07. 02. 2022 10:11",
                "7.2.2022 10:11",
                "7. 2. 2022 10:11",
            ),
            "25.11.21 00:00:00": (
                "07.02.22 10:11",
                "07. 02. 22 10:11",
                "7.2.22 10:11",
                "7. 2. 22 10:11",
            ),
            "11/25/2021 00:00:00": ("02/07/2022 10:11", "2/7/2022 10:11"),
            "11/25/21 00:00:00": ("02/07/22 10:11", "2/7/22 10:11"),
            "20211125000000": ("202202071011",),
        }
        # datetime defaults to 1900, 01, 01
        expected_time = datetime(1900, 1, 1, 10, 11, 12)
        times = {
            "00:00:00": ("10:11:12", "10:11:12.00"),
            "000000": ("101112", "101112.00"),
        }
        expected_time2 = datetime(1900, 1, 1, 10, 11, 0)
        times2 = {
            "00:00:00": ("10:11",),
        }
        expected_year = datetime(2022, 1, 1)
        years = {
            "2021": (2022,),
        }
        expected_day = datetime(1900, 2, 7)
        days = {
            "11-25": ("02-07",),
            "25.11.": ("07.02.", "07. 02.", "7.2.", "7. 2."),
            "11/25": ("02/07", "2/7"),
        }
        data = (
            (expected_date, dates),
            (expected_date_time, date_times),
            (expected_date_time2, date_times2),
            (expected_time, times),
            (expected_time2, times2),
            (expected_year, years),
            (expected_day, days),
        )
        for expected, dts in data:
            for k, dt in dts.items():
                for t in dt:
                    parsed = [
                        pd.to_datetime(t, format=f, errors="coerce")
                        for f in TimeVariable.ADDITIONAL_FORMATS[k][0]
                    ]
                    # test any equal to expected
                    self.assertTrue(any(d == expected for d in parsed))
                    # test that no other equal to any other date - only nan or expected
                    self.assertTrue(any(d == expected or pd.isnull(d) for d in parsed))


PickleContinuousVariable = create_pickling_tests(
    "PickleContinuousVariable",
    ("with_name", lambda: ContinuousVariable(name="Feature 0")),
)

PickleDiscreteVariable = create_pickling_tests(
    "PickleDiscreteVariable",
    ("with_name", lambda: DiscreteVariable(name="Feature 0")),
    ("with_str_value", lambda: DiscreteVariable(name="Feature 0",
                                                values=("F", "M")))
)


PickleStringVariable = create_pickling_tests(
    "PickleStringVariable",
    ("with_name", lambda: StringVariable(name="Feature 0"))
)


class VariableTestMakeProxy(unittest.TestCase):
    def test_make_proxy_disc(self):
        abc = DiscreteVariable("abc", values="abc")
        abc1 = abc.make_proxy()
        abc2 = abc1.make_proxy()
        self.assertEqual(abc, abc1)
        self.assertEqual(abc, abc2)
        self.assertEqual(abc1, abc2)
        self.assertEqual(hash(abc), hash(abc1))
        self.assertEqual(hash(abc1), hash(abc2))

        abcx = DiscreteVariable("abc", values="abc")
        self.assertEqual(abc, abcx)
        self.assertIsNot(abc, abcx)

        abc1p = pickle.loads(pickle.dumps(abc1))
        self.assertEqual(abc1p, abc)

        abcp, abc1p, abc2p = pickle.loads(pickle.dumps((abc, abc1, abc2)))
        self.assertEqual(abcp, abc1p)
        self.assertEqual(abcp, abc2p)
        self.assertEqual(abc1p, abc2p)

    def test_make_proxy_cont(self):
        abc = ContinuousVariable("abc")
        abc1 = abc.make_proxy()
        abc2 = abc1.make_proxy()
        self.assertEqual(abc, abc1)
        self.assertEqual(abc, abc2)
        self.assertEqual(abc1, abc2)
        self.assertEqual(hash(abc), hash(abc1))
        self.assertEqual(hash(abc1), hash(abc2))

    def test_proxy_has_separate_attributes(self):
        image = StringVariable("image")
        image1 = image.make_proxy()
        image2 = image1.make_proxy()

        image.attributes["origin"] = "a"
        image1.attributes["origin"] = "b"
        image2.attributes["origin"] = "c"

        self.assertEqual(image.attributes["origin"], "a")
        self.assertEqual(image1.attributes["origin"], "b")
        self.assertEqual(image2.attributes["origin"], "c")


if __name__ == "__main__":
    unittest.main()