import pythonnet
pythonnet.load('coreclr')
import clr
from System.Collections.Generic import Dictionary, List, KeyValuePair
from System.Collections.Immutable import ImmutableArray, ImmutableList, ImmutableDictionary
from System import Int32, String, Object, Nullable, Array
from System.Collections.Generic import CollectionExtensions

ArrT = Array[Int32]
ImmArrT = ImmutableArray[Int32]
ListT = List[Int32]

arr = ArrT([0, 1, 2, 3, 4])
immarr = ImmutableArray.Create[Int32](0, 1, 2, 3, 4)  # is this supposed to work, instead of using Create()?
lst = ListT(ArrT([0, 1, 2, 3, 4]))
immlst = ImmutableList.ToImmutableList[Int32](ArrT([0, 1, 2, 3, 4]))

arr[-1]     # OK
arr[999]    # OK, raises IndexError
immarr[-1]  # System.IndexOutOfRangeException: Index was outside the bounds of the array.
lst[-1]     # System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
immlst[-1]  # System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values. (Parameter 'index')

    def __getitem__(self, key):
        length = len(self)
        key = key if key >= 0 else length + key
        if key not in range(length):
            raise IndexError('index out of range')
        return self.get_Item(key)

arr.index(999)     # OK, raises ValueError
immarr.index(999)  # System.IndexOutOfRangeException: Index was outside the bounds of the array.
lst.index(999)     # System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
immlst.index(999)  # System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values. (Parameter 'index')

arr[0:3]     # TypeError: array index has type slice, expected an integer
immarr[0:3]  # TypeError: No method matches given arguments for ImmutableArray`1.get_Item: (<class 'slice'>)
lst[0:3]     # TypeError: No method matches given arguments for List`1.get_Item: (<class 'slice'>)
immlst[0:3]  # TypeError: No method matches given arguments for ImmutableList`1.get_Item: (<class 'slice'>)

arr[-1] = 9   # OK
lst[-1] = 9   # System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
arr[999] = 9  # OK, raises IndexError
lst[999] = 9  # System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')

    def __setitem__(self, key, value):
        length = len(self)
        key = key if key >= 0 else length + key
        if key not in range(length):
            raise IndexError('index out of range')
       self.set_Item(key, value)

del arr[4]                # SystemError: Objects/longobject.c:583: bad argument to internal function
arr.insert(0, 5)          # IndexError; calls abc implementation, which is a stub!
arr.append(5)             # IndexError; uses abc implementation, which falls back to insert
arr.pop()                 # SystemError (same as del); uses abc implementation, which calls del
arr.clear()               # SystemError (same as del); uses abc implementation, which calls del
arr.extend([10, 11, 12])  # IndexError; uses abc implementation, which calls append
arr.remove(9)             # SystemError (same as del); uses abc implementation, which calls del
arr += [10, 11, 12]       # IndexError; uses abc implementation, which falls back to extend

del lst[0]  # crash

lst.insert(0, 5)          # IndexError; calls abc implementation, which is a stub!
lst.append(5)             # IndexError; uses abc implementation, which calls insert
lst.pop()                 # IndexError; uses abc implementation, which calls __getitem__(-1) and del
lst.clear()               # IndexError; uses abc implementation, which calls pop
lst.extend([10, 11, 12])  # IndexError; uses abc implementation, which calls append
lst.remove(3)             # CRASH; uses abc implementation, which calls del
lst += [10, 11, 12]       # IndexError; uses abc implementation, which falls back to extend

    def insert(self, index, value):
        self.Insert(index, value)

DictT  = Dictionary[Int32, String]
DictT2 = Dictionary[String, Int32]
DictT3 = Dictionary[String, Nullable[Int32]]

d = DictT()
d[10] = "10"
d[20] = "20"
d[30] = "30"
d2 = DictT2()
d3 = DictT3()
rod = CollectionExtensions.AsReadOnly[Int32, String](DictT(d))  # ReadOnlyDictionary<int, string>
immd = ImmutableDictionary.ToImmutableDictionary[Int32, String](d)  # ImmutableDictionary<int, string>

del d[""]  # CRASH

list(d)  # gives a list of KeyValuePair

d.popitem()   # TypeError: No method matches given arguments for Dictionary`2.get_Item: (<class 'System.Collections.Generic.KeyValuePair[Int32,String]'>)
d2.popitem()  # TypeError: No method matches given arguments for Dictionary`2.get_Item: (<class 'System.Collections.Generic.KeyValuePair[String,Int32]'>)
d3.popitem()  # TypeError: No method matches given arguments for Dictionary`2.get_Item: (<class 'System.Collections.Generic.KeyValuePair[String,Nullable[Int32]]'>)

   def popitem(self):
       try:
           key = next(iter(self.Keys))
       except StopIteration:
           raise KeyError from None
       value = self[key]
       del self[key]
       return key, value

d[40]     # KeyNotFoundException: The given key '40' was not present in the dictionary.
rod[40]   # KeyNotFoundException: The given key '40' was not present in the dictionary.
immd[40]  # KeyNotFoundException: The given key '40' was not present in the dictionary.

d.pop(10)   # OK
d2.pop("10")  # TypeError: No method matches given arguments for Dictionary`2.TryGetValue: (<class 'str'>, <class 'NoneType'>)
d3.pop("10")  # OK
d.setdefault(10, "10")   # OK
d2.setdefault("10", 10)  # TypeError: No method matches given arguments for Dictionary`2.TryGetValue: (<class 'str'>, <class 'NoneType'>)
d3.setdefault("10", 10)  # OK
d3.setdefault("10")      # Also OK