# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) 2009- Spyder Kernels Contributors
#
# Licensed under the terms of the MIT License
# (see spyder_kernels/__init__.py for details)
# -----------------------------------------------------------------------------

"""
Tests for utils.py
"""

# Standard library imports
from collections import defaultdict
import datetime
import sys

# Third party imports
import numpy as np
import pandas as pd
import pytest
import xarray as xr
import PIL.Image

# Local imports
from spyder_kernels.py3compat import PY2
from spyder_kernels.utils.nsview import (
    sort_against, is_supported, value_to_display, get_size,
    get_supported_types, get_type_string, get_numpy_type_string,
    is_editable_type)


def generate_complex_object():
    """Taken from issue #4221."""
    bug = defaultdict(list)
    for i in range(50000):
        a = {j:np.random.rand(10) for j in range(10)}
        bug[i] = a
    return bug


COMPLEX_OBJECT = generate_complex_object()
DF = pd.DataFrame([1,2,3])
DATASET = xr.Dataset({0: pd.DataFrame([1,2]), 1:pd.DataFrame([3,4])})


# --- Tests
# -----------------------------------------------------------------------------
def test_get_size():
    """Test that the size of all values is returned correctly"""

    class RecursionClassNoLen():
        def __getattr__(self, name):
            if name=='size': return self.name
            else:
                return super(object, self).__getattribute__(name)


    length = [list([1,2,3]), tuple([1,2,3]), set([1,2,3]), '123',
              {1:1, 2:2, 3:3}]
    for obj in length:
        assert get_size(obj) == 3

    df = pd.DataFrame([[1,2,3], [1,2,3]])
    assert get_size(df) == (2, 3)

    df = pd.Series([1,2,3])
    assert get_size(df) == (3,)

    df = pd.Index([1,2,3])
    assert get_size(df) == (3,)

    arr = np.array([[1,2,3], [1,2,3]], dtype=np.complex128)
    assert get_size(arr) == (2, 3)

    img = PIL.Image.new('RGB', (256,256))
    assert get_size(img) == (256,256)

    obj = RecursionClassNoLen()
    assert get_size(obj) == 1



def test_sort_against():
    lista = [5, 6, 7]
    listb = [2, 3, 1]
    res = sort_against(lista, listb)
    assert res == [7, 5, 6]


def test_sort_against_is_stable():
    lista = [3, 0, 1]
    listb = [1, 1, 1]
    res = sort_against(lista, listb)
    assert res == lista


def test_none_values_are_supported():
    """Tests that None values are displayed by default"""
    supported_types = get_supported_types()
    mode = 'editable'
    none_var = None
    none_list = [2, None, 3, None]
    none_dict = {'a': None, 'b': 4}
    none_tuple = (None, [3, None, 4], 'eggs')
    assert is_supported(none_var, filters=tuple(supported_types[mode]))
    assert is_supported(none_list, filters=tuple(supported_types[mode]))
    assert is_supported(none_dict, filters=tuple(supported_types[mode]))
    assert is_supported(none_tuple, filters=tuple(supported_types[mode]))


def test_str_subclass_display():
    """Test for value_to_display of subclasses of str/basestring."""
    class Test(str):
        def __repr__(self):
            return 'test'
    value = Test()
    value_display = value_to_display(value)
    assert 'Test object' in value_display


def test_default_display():
    """Tests for default_display."""
    # Display of defaultdict
    assert (value_to_display(COMPLEX_OBJECT) ==
            'defaultdict object of collections module')

    # Display of array of COMPLEX_OBJECT
    assert (value_to_display(np.array(COMPLEX_OBJECT)) ==
            'ndarray object of numpy module')

    # Display of Dataset
    assert (value_to_display(DATASET) ==
            'Dataset object of xarray.core.dataset module')


@pytest.mark.skipif(
    sys.platform == 'darwin' and sys.version_info[:2] == (3, 8),
    reason="Fails on Mac with Python 3.8")
def test_list_display():
    """Tests for display of lists."""
    long_list = list(range(100))

    # Simple list
    assert value_to_display([1, 2, 3]) == '[1, 2, 3]'

    # Long list
    assert (value_to_display(long_list) ==
            '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]')

    # Short list of lists
    assert (value_to_display([long_list] * 3) ==
            '[[0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...]]')

    # Long list of lists
    result = '[' + ''.join('[0, 1, 2, 3, 4, ...], '*10)[:-2] + ']'
    assert value_to_display([long_list] * 10) == result[:70] + ' ...'

    # Multiple level lists
    assert (value_to_display([[1, 2, 3, [4], 5]] + long_list) ==
            '[[1, 2, 3, [...], 5], 0, 1, 2, 3, 4, 5, 6, 7, 8, ...]')
    assert value_to_display([1, 2, [DF]]) == '[1, 2, [Dataframe]]'
    assert value_to_display([1, 2, [[DF], DATASET]]) == '[1, 2, [[...], Dataset]]'

    # List of complex object
    assert value_to_display([COMPLEX_OBJECT]) == '[defaultdict]'

    # List of composed objects
    li = [COMPLEX_OBJECT, DATASET, 1, {1:2, 3:4}, DF]
    result = '[defaultdict, Dataset, 1, {1:2, 3:4}, Dataframe]'
    assert value_to_display(li) == result

    # List starting with a non-supported object (#5313)
    supported_types = tuple(get_supported_types()['editable'])
    li = [len, 1]
    assert value_to_display(li) == '[builtin_function_or_method, 1]'
    assert is_supported(li, filters=supported_types)


@pytest.mark.skipif(
    sys.platform == 'darwin' and sys.version_info[:2] == (3, 8),
    reason="Fails on Mac with Python 3.8")
def test_dict_display():
    """Tests for display of dicts."""
    long_list = list(range(100))
    long_dict = dict(zip(list(range(100)), list(range(100))))

    # Simple dict
    assert value_to_display({0:0, 'a':'b'}) == "{0:0, 'a':'b'}"

    # Long dict
    assert (value_to_display(long_dict) ==
            '{0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, ...}')

    # Short list of lists
    assert (value_to_display({1:long_dict, 2:long_dict}) ==
            '{1:{0:0, 1:1, 2:2, 3:3, 4:4, ...}, 2:{0:0, 1:1, 2:2, 3:3, 4:4, ...}}')

    # Long dict of dicts
    result = ('{(0, 0, 0, 0, 0, ...):[0, 1, 2, 3, 4, ...], '
               '(1, 1, 1, 1, 1, ...):[0, 1, 2, 3, 4, ...]}')
    assert value_to_display({(0,)*100:long_list, (1,)*100:long_list}) == result[:70] + ' ...'

    # Multiple level dicts
    assert (value_to_display({0: {1:1, 2:2, 3:3, 4:{0:0}, 5:5}, 1:1}) ==
            '{0:{1:1, 2:2, 3:3, 4:{...}, 5:5}, 1:1}')
    assert value_to_display({0:0, 1:1, 2:2, 3:DF}) == '{0:0, 1:1, 2:2, 3:Dataframe}'
    assert value_to_display({0:0, 1:1, 2:[[DF], DATASET]}) == '{0:0, 1:1, 2:[[...], Dataset]}'

    # Dict of complex object
    assert value_to_display({0:COMPLEX_OBJECT}) == '{0:defaultdict}'

    # Dict of composed objects
    li = {0:COMPLEX_OBJECT, 1:DATASET, 2:2, 3:{0:0, 1:1}, 4:DF}
    result = '{0:defaultdict, 1:Dataset, 2:2, 3:{0:0, 1:1}, 4:Dataframe}'
    assert value_to_display(li) == result

    # Dict starting with a non-supported object (#5313)
    supported_types = tuple(get_supported_types()['editable'])
    di = {max: len, 1: 1}
    assert value_to_display(di) in (
            '{builtin_function_or_method:builtin_function_or_method, 1:1}',
            '{1:1, builtin_function_or_method:builtin_function_or_method}')
    assert is_supported(di, filters=supported_types)


def test_set_display():
    """Tests for display of sets."""
    long_set = {i for i in range(100)}

    # Simple set
    assert value_to_display({1, 2, 3}) == '{1, 2, 3}'

    # Long set
    disp = '{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...}'
    assert value_to_display(long_set) == disp

    # Short list of sets
    disp = '[{0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}]'
    assert value_to_display([long_set] * 3) == disp

    # Long list of sets
    disp = '[' + ''.join('{0, 1, 2, 3, 4, ...}, '*10)[:-2] + ']'
    assert value_to_display([long_set] * 10) == disp[:70] + ' ...'


def test_datetime_display():
    """Simple tests that dates, datetimes and timedeltas display correctly."""
    test_date = datetime.date(2017, 12, 18)
    test_date_2 = datetime.date(2017, 2, 2)

    test_datetime = datetime.datetime(2017, 12, 18, 13, 43, 2)
    test_datetime_2 = datetime.datetime(2017, 8, 18, 0, 41, 27)

    test_timedelta = datetime.timedelta(-1, 2000)
    test_timedelta_2 = datetime.timedelta(0, 3600)

    # Simple dates/datetimes/timedeltas
    assert value_to_display(test_date) == '2017-12-18'
    assert value_to_display(test_datetime) == '2017-12-18 13:43:02'
    assert value_to_display(test_timedelta) == '-1 day, 0:33:20'

    # Lists of dates/datetimes/timedeltas
    assert (value_to_display([test_date, test_date_2]) ==
            '[2017-12-18, 2017-02-02]')
    assert (value_to_display([test_datetime, test_datetime_2]) ==
            '[2017-12-18 13:43:02, 2017-08-18 00:41:27]')
    assert (value_to_display([test_timedelta, test_timedelta_2]) ==
            '[-1 day, 0:33:20, 1:00:00]')

    # Tuple of dates/datetimes/timedeltas
    assert (value_to_display((test_date, test_datetime, test_timedelta)) ==
            '(2017-12-18, 2017-12-18 13:43:02, -1 day, 0:33:20)')

    # Dict of dates/datetimes/timedeltas
    assert (value_to_display({0: test_date,
                              1: test_datetime,
                              2: test_timedelta_2}) ==
            ("{0:2017-12-18, 1:2017-12-18 13:43:02, 2:1:00:00}"))


def test_str_in_container_display():
    """Test that strings are displayed correctly inside lists or dicts."""
    # Assert that both bytes and unicode return the right display
    assert value_to_display([b'a', u'b']) == "['a', 'b']"

    # Encoded unicode gives bytes and it can't be transformed to
    # unicode again. So this test the except part of
    # is_binary_string(value) in value_to_display
    if PY2:
        assert value_to_display([u'Э'.encode('cp1251')]) == "['\xdd']"


def test_ellipses(tmpdir):
    """
    Test that we're adding a binary ellipses when value_to_display of
    a collection is too long and binary.

    For issue 6942
    """
    # Create binary file with all bytes
    file = tmpdir.new(basename='bytes.txt')
    file.write_binary(bytearray(list(range(255))))

    # Read bytes back
    buffer = file.read(mode='rb')

    # Assert that there's a binary ellipses in the representation
    assert b' ...' in value_to_display(buffer)


def test_get_type_string():
    """Test for get_type_string."""
    # Bools
    assert get_type_string(True) == 'bool'

    # Numeric types (PY2 has long, which disappeared in PY3)
    if not PY2:
        expected = ['int', 'float', 'complex']
        numeric_types = [1, 1.5, 1 + 2j]
        assert [get_type_string(t) for t in numeric_types] == expected

    # Lists
    assert get_type_string([1, 2, 3]) == 'list'

    # Sets
    assert get_type_string({1, 2, 3}) == 'set'

    # Dictionaries
    assert get_type_string({'a': 1, 'b': 2}) == 'dict'

    # Tuples
    assert get_type_string((1, 2, 3)) == 'tuple'

    # Strings
    if not PY2:
        assert get_type_string('foo') == 'str'

    # Numpy objects
    assert get_type_string(np.array([1, 2, 3])) == 'NDArray'

    masked_array = np.ma.MaskedArray([1, 2, 3], mask=[True, False, True])
    assert get_type_string(masked_array) == 'MaskedArray'

    matrix = np.matrix([[1, 2], [3, 4]])
    assert get_type_string(matrix) == 'Matrix'

    # Pandas objects
    df = pd.DataFrame([1, 2, 3])
    assert get_type_string(df) == 'DataFrame'

    series = pd.Series([1, 2, 3])
    assert get_type_string(series) == 'Series'

    index = pd.Index([1, 2, 3])
    assert get_type_string(index) in ['Int64Index', 'Index']

    # PIL images
    img = PIL.Image.new('RGB', (256,256))
    assert get_type_string(img) == 'PIL.Image.Image'

    # Datetime objects
    date = datetime.date(2010, 10, 1)
    assert get_type_string(date) == 'datetime.date'

    date = datetime.timedelta(-1, 2000)
    assert get_type_string(date) == 'datetime.timedelta'


def test_is_editable_type():
    """Test for get_type_string."""
    # Bools
    assert is_editable_type(True)

    # Numeric type
    numeric_types = [1, 1.5, 1 + 2j]
    assert all([is_editable_type(t) for t in numeric_types])

    # Lists
    assert is_editable_type([1, 2, 3])

    # Sets
    assert is_editable_type({1, 2, 3})

    # Dictionaries
    assert is_editable_type({'a': 1, 'b': 2})

    # Tuples
    assert is_editable_type((1, 2, 3))

    # Strings
    assert is_editable_type('foo')

    # Numpy objects
    assert is_editable_type(np.array([1, 2, 3]))

    masked_array = np.ma.MaskedArray([1, 2, 3], mask=[True, False, True])
    assert is_editable_type(masked_array)

    matrix = np.matrix([[1, 2], [3, 4]])
    assert is_editable_type(matrix)

    # Pandas objects
    df = pd.DataFrame([1, 2, 3])
    assert is_editable_type(df)

    series = pd.Series([1, 2, 3])
    assert is_editable_type(series)

    index = pd.Index([1, 2, 3])
    assert is_editable_type(index)

    # PIL images
    img = PIL.Image.new('RGB', (256,256))
    assert is_editable_type(img)

    # Datetime objects
    date = datetime.date(2010, 10, 1)
    assert is_editable_type(date)

    date = datetime.timedelta(-1, 2000)
    assert is_editable_type(date)

    # Other objects
    class MyClass:
        a = 1
    assert not is_editable_type(MyClass)

    my_instance = MyClass()
    assert not is_editable_type(my_instance)


def test_get_numpy_type():
    """Test for get_numpy_type_string."""
    # Numpy objects
    assert get_numpy_type_string(np.array([1, 2, 3])) == 'Array'

    matrix = np.matrix([[1, 2], [3, 4]])
    assert get_numpy_type_string(matrix) == 'Array'

    assert get_numpy_type_string(np.int32(1)) == 'Scalar'

    # Regular Python objects
    assert get_numpy_type_string(1.5) == 'Unknown'
    assert get_numpy_type_string([1, 2, 3]) == 'Unknown'
    assert get_numpy_type_string({1: 2}) == 'Unknown'

    # PIL images
    img = PIL.Image.new('RGB', (256,256))
    assert get_numpy_type_string(img) == 'Unknown'

    # Pandas objects
    df = pd.DataFrame([1, 2, 3])
    assert get_numpy_type_string(df) == 'Unknown'


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