from stdlib import malloc, free
import ctypes
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.DerefAs(p, v)

GLOBAL_VAR: t.CInt = 0

@t.Object
class OOPTest2:
    fb: t.CVoid | t.CPtr
    def __init__(self):
        self.fb = malloc(1024)
        for i in range(0, 1024):
            self.fb[i] = '1'
        c.Set(t.CChar(self.fb[1023], t.CPtr), '\0')
    def GetFB(self) -> t.CChar | t.CPtr:
        return t.CChar(self.fb, t.CPtr)
    def __del__(self):
        print("OOPTest2 __del__")
        free(self.fb)

@t.Object
class OOPTest:
    a: UINT
    b: UINT = 12345
    c: UINT
    oop2: OOPTest2 | t.CPtr
    def __init__(self):
        self.a = 451
        self.oop2 = c.Addr(OOPTest2())
        # c.Set(c.Deref(self.oop2.GetFB()[0]), 1)
        self.oop2.GetFB()[0] = '1'
        cp = self.oop2.fb # t.CChar(self.oop2.fb, t.CPtr)
        cp[1] = '4'
        cp[2] = '5'
        cp[3] = '6'
        cp[4] = '7'
        cp[5] = '8'
        cp[6] = '9'
        cp[7] = '0'
        cp[8] = '9'

        print(t.CChar(cp[0], t.CPtr))
        print("长度：", t.CChar(cp, t.CPtr).__sizeof__())
        print("cp[0]:", cp[0])
        cp += 1
        print("cp[0]:", cp[0])
        cp += 1
 
        print("self.oop2.GetFB()[0]:", int(cp[0]))
        #k = t.CChar(self.oop2.fb[1], t.CPtr)
        #k[0] = "4"

        cp -= 2
        # print(t.CChar(cp, t.CPtr))

        lambda_a = lambda: 1
        print(cp[0], lambda_a())

        print(type(cp))
        print(dir(OOPTest2))

        vkt: t.CVoid | t.CPtr = malloc(1024)
        c.Set(c.Deref(vkt[0]), 8080)
        vkt[0] = '2'
        # vkt[0] = 20
        print(t.CChar(vkt[0], t.CPtr)[0])
        print(type(vkt[0]))
        print(t.CChar(t.CInt("Hello"), t.CPtr))
        print(str((c.Addr("你好"))))
        # print(vkt)
        free(vkt)
        # print("vkt:", vkt)

        vkt: t.CVoid | t.CPtr = malloc(1024)
        vkt2: t.CChar | t.CPtr = t.CChar(vkt, t.CPtr)
        vkt2[0] = '1'
        vkt2[100] = '1'
        print("首个参数：", vkt2[0])
        print("第100参数：", vkt2[100])
        #print("HEX", str_to_hex(vkt))
        free(vkt)
        print("HEX", str_to_hex("ABCDEFHIJKLMN"))
        print("HEX", str_to_hex("1"))

        del self.oop2


def str_to_hex(s: str) -> str:
    buf: str = malloc(1024)
    out: str = buf
    hex: list[str, None] = "0123456789ABCDEF"
    while c.Deref(s) != 0:
        cr: t.CUnsignedChar = c.Deref(s)
        c.Set(c.Deref(out), hex[(cr >> 4) & 0xF]) # 高 4 位
        out += 1
        c.Set(c.Deref(out), hex[cr & 0xF]) # 低 4 位
        out += 1
        s += 1  # 移动指针！
    c.Set(c.Deref(out), 0) # 结尾
    return buf

# 十进制 int → 16进制字符串（小写 0x 开头）
# 内部 malloc(128)，外部必须 free()
def int_to_hex(num: int) -> str:
    buf = t.CChar(malloc(128), t.CPtr)
    if not buf: return None

    hex_chars: list[t.CChar, None] = "0123456789ABCDEF"
    i = 0

    # 先加 0x 前缀
    buf[i] = '0'
    buf[i + 1] = 'x'
    i += 2

    # 处理 0
    if num == 0:
        buf[i] = '0'
        i += 1
        buf[i] = '0'
        i += 1
        buf[i] = '\0'
        return buf

    # 存储逆序的十六进制字符
    temp: list[t.CChar, 32]
    temp_idx = 0

    # 转为无符号，避免负数问题
    n: t.CUnsignedInt = t.CUnsignedInt(num)

    while n > 0:
        rem: t.CInt = n & 0xF;       # 取低4位（等价%16）
        temp[temp_idx] = hex_chars[rem]
        temp_idx += 1
        n = n >> 4;              # 右移4位（等价/16）

    # 反转写入最终缓冲区
    while temp_idx > 0:
        temp_idx -= 1
        buf[i] = temp[temp_idx]
        i += 1

    buf[i] = '\0'
    return buf



def int_to_str(num: int) -> str:
    # 直接分配 128 字节（足够存任何 64 位整数）
    buf: t.CChar | t.CPtr = t.CChar(malloc(128), t.CPtr)
    if not buf: return None
    is_negative = 0
    i = 0
    # 处理 0
    if num == 0:
        buf[i] = '0'
        i += 1
        buf[i] = '\0'
        return buf
    # 处理负数
    if num < 0:
        is_negative = 1
        num = -num
    # 生成逆序数字
    while num > 0:
        rem = num % 10
        buf[i] = '0' + rem
        i += 1
        num = num / 10
    # 负号
    if is_negative:
        buf[i] = '-'
        i += 1
    # 结束符
    buf[i] = '\0'
    # 反转字符串
    start = 0
    end = i - 1
    while start < end:
        tr: t.CChar = buf[start]
        buf[start] = buf[end]
        buf[end] = tr
        start += 1
        end -= 1
    return buf










# 一个元素：存 数据指针 + 数据大小
class Item:
    data: t.CVoid | t.CPtr  # i8* 数据指针
    size: t.CSizeT # 存字节大小（用于拷贝、释放）

# 可变长列表
class List:
    items:    Item | t.CPtr
    count:    t.CSizeT = 0
    capacity: t.CSizeT = 4
    # 初始化列表
    def __init__(self):
        # l: List | t.CPtr = malloc(List.__sizeof__())
        self.count = 0
        self.capacity = 4
        self.items = malloc(self.capacity * Item.__sizeof__())

    # 自动扩容
    def __grow(self):
        if self.count >= self.capacity:
            self.capacity *= 2
            self.items = realloc(self.items, self.capacity * Item.__sizeof__())

    # 添加任意类型数据（深拷贝）
    def append(self, data: t.CVoid | t.CPtr, size: t.CSizeT):
        self.__grow()
        item: Item | t.CPtr = self.items[self.count]
        item.size = size
        item.data = malloc(size + 1)
        memcpy(item.data, data, size)
        c.Set(t.CUnsignedChar(item.data + size, t.CPtr), '\0')
        self.count += 1

    # 获取元素：返回 i8*（int8_t*），强转
    def get(self, index: t.CSizeT) -> t.CInt8T | t.CPtr:
        if index >= self.count: return None
        return self.items[index].data

    def __getitem__(self, index: t.CSizeT) -> t.CInt8T | t.CPtr:
        return self.get(index)

    # 销毁列表（所有内存全部释放）
    def free(self):
        i: t.CSizeT = 0
        for i in range(self.count):
            if self.items[i].data != 0:
                free(self.items[i].data)
        free(self.items)
        # free(self)






DEFINE_T: t.CDefine = 2423432423


class EnumTest(t.CEnum):
    A: t.State
    B: t.State
    C: t.State
    Len: t.State


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

    d = OOPTest()

    l = List()
    nihao = "你好！世界，这是一个可变列表"
    l.append(c.Addr(114514), t.CInt.__sizeof__())
    l.append(nihao, len(nihao))
    print("列表取值0：", c.Deref(t.CInt(l[0], t.CPtr)))
    print("列表取值1：", l.get(1))
    l.free()
    # free(l)
    print("结束")

    # 未实现
    #a = t.CInt32T
    #print(a(-1))
    #print(type(a(-1)))

    E: EnumTest = EnumTest.B
    print(E)
    print(EnumTest.Len)

    print(EnumTest(1))
    print(type(EnumTest.B))

    # c.Asm("mov eax, 1", op=[t.ASM_DESCR.CLOBBER_EAX])

    u = Union()
    u.A.a = 114514
    u.A.b = 222222
    print("u.A.a", u.A.a)
    print("u.A.b", u.A.b)
    print("u.A.c", u.B.c) # -16558

    wb = WBIT()
    wb.a = 1
    wb.b = 1
    wb.c = 1
    wb.d = 12
    print(wb.a)
    print(wb.b)
    print(wb.c)
    print(wb.d)
    wb.a = 2
    print(wb.a) # 10 -> 0 -> 0
    print(wb.__sizeof__())
    print(type(wb))

    ble = BLE()
    ble.a = 0x114514
    ble.b = 0x114514
    print(ble.a)
    print(ble.b)
    print("a:", int_to_str(ble.a))
    print("a_hex:", str_to_hex(int_to_str(ble.a)))
    print(int_to_hex(ble.a[0])) # 0x00114514 00
    print(int_to_hex(ble.a[1])) # 0x00114514 11
    print(int_to_hex(ble.a[2])) # 0x00114514 45
    print(int_to_hex(ble.a[3])) # 0x00114514 14

    print(int_to_hex(ble.b[0])) # 0x00114514 14
    print(int_to_hex(ble.b[1])) # 0x00114514 45
    print(int_to_hex(ble.b[2])) # 0x00114514 11
    print(int_to_hex(ble.b[3])) # 0x00114514 00

    li = 0x0000000100000001

    #bool_ = 0
    #if bool_:
    #    tcls = t.CUInt32T
    #else:
    #    tcls = LIWORK
    #lx = tcls(li)
    #print(type(lx))
    #print(lx.b)
    #print("END")
    #未能完全实现
    # x[-1]取值

    print(DEFINE_T)
    if c.CIf(DEFINE_T == 2423432423):
        print("DEFINE_T == 2423432423")
    elif c.CIf(DEFINE_T == 123):
        print("DEFINE_T == 123")
    else:
        print("DEFINE_T != 2423432423 and DEFINE_T != 123")
    #c.CIf
    #c.CIfdef
    #c.CIfndef
    #c.CElif
    #c.CElse

class LIWORK:
    a: t.CUInt32T
    b: t.CUInt32T

# class Union
class Union(t.CUnion):
    class A:
        a: t.CInt32T
        b: t.CInt32T
    class B:
        c: t.CInt16T
        d: t.CInt64T

class WBIT:
    a: t.CInt | t.Bit(1)
    b: t.CInt | t.Bit(1)
    c: t.CInt | t.Bit(1)
    d: t.CInt | t.Bit(5)

class BLE:
    a: t.CInt | t.BigEndian
    b: t.CInt | t.LittleEndian