from string import atoi
from stdlib import malloc, free
from stdint import *
import string
import w32.win32console
from stdarg import va_start, va_end, va_arg, va_list
import t
import c


class Struct1:
    a: UINT
    b: UINT = 123
S1: list[Struct1, 5] = [
    Struct1(1, 2),
    Struct1(b=3, a=4),
    Struct1(a=5, b=6),
    Struct1(7, b=8),
    Struct1(9)
]
S1_: Struct1 = Struct1(10)
S1_2 = Struct1(112)


def reptr(p: UINT | t.CPtr, v: UINT):
    c.Set(c.Deref(p), v)

GLOBAL_VAR: t.CInt = 0

@t.Object
class OOPTest:
    a: UINT
    b: UINT = 12345
    c: UINT
    def __init__(self):
        self.a = 451
    def set_c(self, v: UINT):
        self.c = v
        global GLOBAL_VAR
        GLOBAL_VAR = v
    def __call__(self, a: UINT, b: UINT) -> UINT:
        # print(a, b)
        return a + b
    def __enter__(self) -> 'OOPTest' | t.CPtr:
        return self
    def __exit__(self):
        self.a = 99
        self.b = 99
        self.c = 99
    def __add__(self, other: 'OOPTest' | t.CPtr) -> 'OOPTest' | t.CPtr:
        s = OOPTest()
        s.a = (self.a + other.a)
        return s
    def print1(self):
        print(114514)
    def __str__(self) -> str:
        return f"OOPTest ({self.a}) ({self.b}) ({self.c})"
    def __delete__(self, instance):
        print(f"delete {instance}")
    def __bool__(self) -> bool:
        return bool(self.a != 0)
    def __len__(self) -> UINT:
        return self.a
    def __delitem__(self, key: UINT):
        print(f"delitem {key}")
    def __getitem__(self, key: UINT) -> UINT:
        print(f"getitem {key}")
        return self.a
    def __setitem__(self, key: UINT, value: UINT):
        print(f"setitem {key} {value}")
        self.a = value
    def __abs__(self) -> UINT:
        if self.a < 0:
            return -self.a
        return self.a


@t.Object
class RangeOOPSimulation:
    start: UINT
    end: UINT
    def __init__(self, start: UINT, end: UINT):
        self.start = start
        self.end = end

    def __iter__(self) -> 'RangeOOPSimulation' | t.CPtr:
        return self

    def __next__(self) -> UINT:
        if self.start >= self.end:
            raise StopIteration
        self.start += 1
        return self.start - 1

def main() -> t.CInt:
    w32.win32console.SetConsoleOutputCP(65001)
    w32.win32console.SetConsoleCP(65001)

    d = OOPTest()
    d.set_c(1000000)
    d.a = 1
    print("d.a: ", d.a)
    print("d.b: ", d.b)
    print("d.c: ", d.c)
    #print(GLOBAL_VAR)

    with OOPTest() as d:
        print("with __call__:", d(1, 2))
    print("_d.a: ", d.a)
    print("_d.b: ", d.b)
    print("_d.c: ", d.c)

    l = OOPTest()
    l.a = 100
    (d + l).print1()
    print("d + l.a: ", d.a + l.a)
    print("(d + l).a: ", (d + l).a)

    print(f"d.a, l.a: {d.a} {l.a}")
    print("d:", d)

    if d:
        print("d.a 不是 zero， 说得对", d.a)
    else:
        print("d.a 是 zero， 说得对")
    print("abs(d):", abs(d))
    print("len(d):", len(d))
    del d[114514]
    d[114514] = 1145142

    llll = "你好"
    print(f"{llll}，世界")
    
    for i in RangeOOPSimulation(0, 5 + 1):
        print("RangeOOPSimulation:", i)
    
    free(d)
    callit_args(0, 1, 2, "你知道", 666)


# args
def callit_args(a: t.CInt, *args):
    print(arg(int), arg(int), arg(str), arg(int))
    #l: t.CInt = va_arg(args_va_list, int)
    #print(l)