# -*- coding: utf-8 -*-

"""Test CLR interface support."""

import Python.Test as Test
import pytest

from .utils import DictProxyType


def test_interface_standard_attrs():
    """Test standard class attributes."""
    from Python.Test import IPublicInterface

    assert IPublicInterface.__name__ == 'IPublicInterface'
    assert IPublicInterface.__module__ == 'Python.Test'
    assert isinstance(IPublicInterface.__dict__, DictProxyType)


def test_global_interface_visibility():
    """Test visibility of module-level interfaces."""
    from Python.Test import IPublicInterface

    assert IPublicInterface.__name__ == 'IPublicInterface'

    with pytest.raises(ImportError):
        from Python.Test import IInternalInterface
        _ = IInternalInterface

    with pytest.raises(AttributeError):
        _ = Test.IInternalInterface


def test_nested_interface_visibility():
    """Test visibility of nested interfaces."""
    from Python.Test import InterfaceTest

    ob = InterfaceTest.IPublic
    assert ob.__name__ == 'IPublic'

    ob = InterfaceTest.IProtected
    assert ob.__name__ == 'IProtected'

    with pytest.raises(AttributeError):
        _ = InterfaceTest.IInternal

    with pytest.raises(AttributeError):
        _ = InterfaceTest.IPrivate


def test_explicit_cast_to_interface():
    """Test explicit cast to an interface."""
    from Python.Test import InterfaceTest

    ob = InterfaceTest()
    assert type(ob).__name__ == 'InterfaceTest'
    assert hasattr(ob, 'HelloProperty')

    i1 = Test.ISayHello1(ob)
    assert type(i1).__name__ == 'ISayHello1'
    assert hasattr(i1, 'SayHello')
    assert i1.SayHello() == 'hello 1'
    assert not hasattr(i1, 'HelloProperty')
    assert i1.__implementation__ == ob
    assert i1.__raw_implementation__ == ob

    i2 = Test.ISayHello2(ob)
    assert type(i2).__name__ == 'ISayHello2'
    assert i2.SayHello() == 'hello 2'
    assert hasattr(i2, 'SayHello')
    assert not hasattr(i2, 'HelloProperty')


def test_interface_object_returned_through_method():
    """Test interface type is used if method return type is interface"""
    from Python.Test import InterfaceTest

    ob = InterfaceTest()
    hello1 = ob.GetISayHello1()
    assert type(hello1).__name__ == 'ISayHello1'
    assert hello1.__implementation__.__class__.__name__ == "InterfaceTest"

    assert hello1.SayHello() == 'hello 1'


def test_interface_object_returned_through_out_param():
    """Test interface type is used for out parameters of interface types"""
    from Python.Test import InterfaceTest

    ob = InterfaceTest()
    hello2 = ob.GetISayHello2(None)
    assert type(hello2).__name__ == 'ISayHello2'

    assert hello2.SayHello() == 'hello 2'

def test_interface_out_param_python_impl():
    from Python.Test import IOutArg, OutArgCaller

    class MyOutImpl(IOutArg):
        __namespace__ = "Python.Test"

        def MyMethod_Out(self, name, index):
            other_index = 101
            return ('MyName', other_index)

    py_impl = MyOutImpl()

    assert 101 == OutArgCaller.CallMyMethod_Out(py_impl)


def test_null_interface_object_returned():
    """Test None is used also for methods with interface return types"""
    from Python.Test import InterfaceTest

    ob = InterfaceTest()
    hello1, hello2 = ob.GetNoSayHello(None)
    assert hello1 is None
    assert hello2 is None

def test_interface_array_returned():
    """Test interface type used for methods returning interface arrays"""
    from Python.Test import InterfaceTest

    ob = InterfaceTest()
    hellos = ob.GetISayHello1Array()
    assert type(hellos[0]).__name__ == 'ISayHello1'
    assert hellos[0].__implementation__.__class__.__name__ == "InterfaceTest"

def test_implementation_access():
    """Test the __implementation__ and __raw_implementation__ properties"""
    import System
    clrVal =  System.Int32(100)
    i = System.IComparable(clrVal)
    assert 100 == i.__implementation__
    assert clrVal == i.__raw_implementation__
    assert i.__implementation__ != i.__raw_implementation__


def test_interface_collection_iteration():
    """Test interface type is used when iterating over interface collection"""
    import System
    from System.Collections.Generic import List
    elem = System.IComparable(System.Int32(100))
    typed_list = List[System.IComparable]()
    typed_list.Add(elem)
    for e in typed_list:
        assert type(e).__name__ == "IComparable"

    untyped_list = System.Collections.ArrayList()
    untyped_list.Add(elem)
    for e in untyped_list:
        assert type(e).__name__ == "int"


def test_methods_of_Object_are_available():
    """Test calling methods inherited from Object"""
    import System
    clrVal =  System.Int32(100)
    i = System.IComparable(clrVal)
    assert i.Equals(clrVal)
    assert clrVal.GetHashCode() == i.GetHashCode()
    assert clrVal.GetType() == i.GetType()
    assert clrVal.ToString() == i.ToString()