# SPDX-License-Identifier: MIT
values = [3, -2, 3, 0, -9, 1]
alias = values
print(values.sort(), values, alias is values, alias)
print(values.sort(reverse=True), values)
print(values.sort(key=abs), values)
print(values.sort(key=abs, reverse=-2147483648), values)
empty = []
print(empty.sort(), empty)
empty.append(7)
print(empty.sort(), empty)
bools = [True, False, True, False]
print(bools.sort(), bools)
words = ["雪", "é", "a", "😀"]
print(words.sort(), words)
bytes_values = [b"\xff", b"a", b"\x00", b"a"]
print(bytes_values.sort(reverse=True), bytes_values)
pairs = [("b", 2), ("a", 1), ("c", 2), ("d", 1)]
print(pairs.sort(key=lambda pair: pair[1]), pairs)
print(pairs.sort(key=lambda pair: pair[1], reverse=True), pairs)

class Item:
    def __init__(self, label, group):
        self.label = label
        self.group = group
items = [Item("a", 2), Item("b", 1), Item("c", 2)]
first = items[0]
print(items.sort(key=lambda item: item.group))
print([item.label for item in items], items[1] is first)
class Keys:
    def score(self, value):
        return -value
bound_values = [1, 3, 2]
print(bound_values.sort(key=Keys().score), bound_values)

events = []
ordered = [3, 1, 2]
def receiver():
    events.append("receiver")
    return ordered
def key_factory():
    events.append("key expression")
    def key(value):
        events.append(str(value) + ":" + str(len(ordered)))
        return value
    return key
def direction():
    events.append("reverse expression")
    return True
print(receiver().sort(reverse=direction(), key=key_factory()), ordered, events)

def check(mode):
    data = [3, 1, 2]
    shared = data
    observed = []
    calls = []
    def key(value):
        observed.append(len(shared))
        calls.append(value)
        if mode == "append" or mode == "append-fail":
            shared.append(99)
        elif mode == "append-pop":
            shared.append(99)
            shared.pop()
        elif mode == "append-remove":
            shared.append(99)
            shared.remove(99)
        elif mode == "append-clear":
            shared.append(99)
            shared.clear()
        elif mode == "insert-clear":
            shared.insert(0, 99)
            shared.clear()
        elif mode == "extend-clear":
            shared.extend([99])
            shared.clear()
        elif mode == "clear":
            shared.clear()
        elif mode == "reverse":
            shared.reverse()
        elif mode == "empty-extend":
            shared.extend([])
        elif mode == "nested":
            shared.sort()
        elif mode == "append-nested-clear":
            shared.append(99)
            shared.sort()
            shared.clear()
        if (mode == "fail" or mode == "append-fail") and value == 1:
            raise ValueError("key stopped")
        return value
    try:
        result = data.sort(key=key, reverse=True)
        print(mode, result, data, shared is data, observed, calls)
    except ValueError as error:
        print(mode, str(error), data, shared is data, observed, calls)
for mode in ["observe", "append", "append-pop", "append-remove", "append-clear", "insert-clear", "extend-clear", "clear", "reverse", "empty-extend", "nested", "append-nested-clear", "fail", "append-fail"]:
    check(mode)

overflow = [2, 1]
try:
    overflow.sort(reverse=2147483648)
except OverflowError as error:
    print(type(error).__name__, str(error), overflow)