from stdint import *
import win32.win32console
import viperlib
import stdlib
import testcheck


# === OOP inheritance + virtual methods ===

virtual class Shape:
    x: double
    y: double

    def __init__(self, x: double, y: double):
        self.x = x
        self.y = y
    def area(self) -> double:
        return 0.0
    def perimeter(self) -> double:
        return 0.0
    def describe(self) -> double:
        return self.area() + self.perimeter()

virtual class Circle(Shape):
    r: double

    def __init__(self, x: double, y: double, r: double):
        self.x = x
        self.y = y
        self.r = r
    def area(self) -> double:
        return 3.14159265 * self.r * self.r
    def perimeter(self) -> double:
        return 2.0 * 3.14159265 * self.r
    def scale(self, factor: double) -> 'Circle' | CPtr:
        self.r = self.r * factor
        return self
    def move(self, dx: double, dy: double) -> 'Circle' | CPtr:
        self.x = self.x + dx
        self.y = self.y + dy
        return self

virtual class Rect(Shape):
    w: double
    h: double

    def __init__(self, x: double, y: double, w: double, h: double):
        self.x = x
        self.y = y
        self.w = w
        self.h = h
    def area(self) -> double:
        return self.w * self.h
    def perimeter(self) -> double:
        return 2.0 * (self.w + self.h)
    def scale(self, factor: double) -> Rect*:
        self.w = self.w * factor
        self.h = self.h * factor
        return self


# === operator overloading + chained calls (heap allocated) ===

class Vec2:
    x: double
    y: double

    def __new__() -> Vec2*:
        return stdlib.malloc(16)

    def __init__(self, x: double, y: double):
        self.x = x
        self.y = y

    def __add__(self, b: Vec2*) -> Vec2*:
        return Vec2(self.x + b.x, self.y + b.y)

    def __sub__(self, b: Vec2*) -> Vec2*:
        return Vec2(self.x - b.x, self.y - b.y)

    def __mul__(self, s: double) -> Vec2*:
        return Vec2(self.x * s, self.y * s)

    def __neg__(self) -> Vec2*:
        return Vec2(-self.x, -self.y)

    def dot(self, b: Vec2*) -> double:
        return self.x * b.x + self.y * b.y

    def len_sq(self) -> double:
        return self.x * self.x + self.y * self.y


class Vec3:
    x: double
    y: double
    z: double

    def __new__() -> Vec3*:
        return stdlib.malloc(24)

    def __init__(self, x: double, y: double, z: double):
        self.x = x
        self.y = y
        self.z = z

    def __add__(self, b: Vec3*) -> Vec3*:
        return Vec3(self.x + b.x, self.y + b.y, self.z + b.z)

    def __sub__(self, b: Vec3*) -> Vec3*:
        return Vec3(self.x - b.x, self.y - b.y, self.z - b.z)

    def __mul__(self, s: double) -> Vec3*:
        return Vec3(self.x * s, self.y * s, self.z * s)

    def __neg__(self) -> Vec3*:
        return Vec3(-self.x, -self.y, -self.z)

    def dot(self, b: Vec3*) -> double:
        return self.x * b.x + self.y * b.y + self.z * b.z

    def cross(self, b: Vec3*) -> Vec3*:
        return Vec3(self.y * b.z - self.z * b.y,
                     self.z * b.x - self.x * b.z,
                     self.x * b.y - self.y * b.x)

    def len_sq(self) -> double:
        return self.dot(self)


# === standalone classes (no inheritance) ===

virtual class Dog:
    name_val: int
    health: int32
    bark_power: int32

    def __init__(self, name_val: int, bark_power: int32):
        self.name_val = name_val
        self.health = int32(100)
        self.bark_power = bark_power
    def speak(self) -> int:
        return 1
    def bite(self) -> int32:
        return self.bark_power
    def take_damage(self, dmg: int32) -> Dog*:
        self.health = self.health - dmg
        return self
    def is_alive(self) -> int:
        if self.health > 0:
            return 1
        return 0

virtual class Cat:
    name_val: int
    health: int32
    lives: int32

    def __init__(self, name_val: int, lives: int32):
        self.name_val = name_val
        self.health = int32(80)
        self.lives = lives
    def speak(self) -> int:
        return 2
    def scratch(self) -> int32:
        return int32(15)
    def take_damage(self, dmg: int32) -> Cat*:
        self.health = self.health - dmg
        return self
    def is_alive(self) -> int:
        if self.health > 0:
            return 1
        return 0


# === nested object composition (heap allocated) ===

class Transform:
    px: double
    py: double
    pz: double
    scale_x: double
    scale_y: double
    scale_z: double

    def __new__() -> Transform*:
        return stdlib.malloc(48)

    def __init__(self, px: double, py: double, pz: double):
        self.px = px
        self.py = py
        self.pz = pz
        self.scale_x = 1.0
        self.scale_y = 1.0
        self.scale_z = 1.0

    def apply_scale(self, sx: double, sy: double, sz: double) -> Transform*:
        self.scale_x = self.scale_x * sx
        self.scale_y = self.scale_y * sy
        self.scale_z = self.scale_z * sz
        return self

    def world_position(self) -> Vec3*:
        return Vec3(self.px * self.scale_x, self.py * self.scale_y, self.pz * self.scale_z)


# === multilevel inheritance (subclasses override only what they need) ===

virtual class Vehicle:
    speed: int32
    fuel: int32

    def __init__(self, speed: int32):
        self.speed = speed
        self.fuel = int32(100)
    def move(self) -> int:
        self.fuel = self.fuel - int32(10)
        return self.speed
    def is_running(self) -> int:
        if self.fuel > 0:
            return 1
        return 0

virtual class Car(Vehicle):
    doors: int32

    def __init__(self, speed: int32, doors: int32):
        self.speed = speed
        self.fuel = int32(100)
        self.doors = doors
    def honk(self) -> int:
        return 1

virtual class ElectricCar(Car):
    battery: int32

    def __init__(self, speed: int32, doors: int32, battery: int32):
        self.speed = speed
        self.fuel = int32(100)
        self.doors = doors
        self.battery = battery
    def charge(self):
        self.battery = self.battery + int32(20)
    def move(self) -> int:
        self.battery = self.battery - int32(5)
        return self.speed


export def main() -> int:
    win32.win32console.SetConsoleCP(65001)
    win32.win32console.SetConsoleOutputCP(65001)

    testcheck.begin("OopInheritTest: OOP 继承与多态专项测试")

    buf: str = stdlib.malloc(256)

    # === OOP inheritance test ===
    testcheck.section("OOP 继承测试")
    c1 = Circle(0.0, 0.0, 5.0)
    viperlib.snprintf(buf, 256, "Circle area=%.2f perim=%.2f", c1.area(), c1.perimeter())
    print(buf)

    r1 = Rect(0.0, 0.0, 4.0, 3.0)
    viperlib.snprintf(buf, 256, "Rect area=%.2f perim=%.2f", r1.area(), r1.perimeter())
    print(buf)

    # chained calls: scale -> move
    c2 = Circle(1.0, 2.0, 3.0)
    c2.scale(2.0).move(10.0, 20.0)
    viperlib.snprintf(buf, 256, "Circle after scale+move: x=%.1f y=%.1f r=%.1f area=%.2f",
                      c2.x, c2.y, c2.r, c2.area())
    print(buf)

    r2 = Rect(0.0, 0.0, 10.0, 5.0)
    r2.scale(2.0).scale(0.5)
    viperlib.snprintf(buf, 256, "Rect after double scale: w=%.1f h=%.1f area=%.2f",
                      r2.w, r2.h, r2.area())
    print(buf)
    testcheck.ok("OOP 继承测试完成")

    # === Vec2 operator overloading + chained calls (heap) ===
    testcheck.section("Vec2 运算符重载 + 链式调用")
    v1 = Vec2(3.0, 4.0)
    v2 = Vec2(1.0, 2.0)
    v3 = v1 + v2
    viperlib.snprintf(buf, 256, "Vec2 add: (%.1f, %.1f)", v3.x, v3.y)
    print(buf)

    v4 = v1 - v2
    viperlib.snprintf(buf, 256, "Vec2 sub: (%.1f, %.1f)", v4.x, v4.y)
    print(buf)

    v5 = v1 * 2.0
    viperlib.snprintf(buf, 256, "Vec2 mul: (%.1f, %.1f)", v5.x, v5.y)
    print(buf)

    v6 = -v1
    viperlib.snprintf(buf, 256, "Vec2 neg: (%.1f, %.1f)", v6.x, v6.y)
    print(buf)

    d = v1.dot(v2)
    viperlib.snprintf(buf, 256, "Vec2 dot: %.1f", d)
    print(buf)

    # chained op: (v1 + v2) * 3.0
    v_chain = (v1 + v2) * 3.0
    viperlib.snprintf(buf, 256, "Vec2 chain (v1+v2)*3: (%.1f, %.1f)", v_chain.x, v_chain.y)
    print(buf)
    testcheck.ok("Vec2 运算符重载测试完成")

    # === Vec3 operator overloading + chained calls (heap) ===
    testcheck.section("Vec3 运算符重载 + 链式调用")
    a1 = Vec3(1.0, 0.0, 0.0)
    a2 = Vec3(0.0, 1.0, 0.0)
    cross_v = a1.cross(a2)
    viperlib.snprintf(buf, 256, "Vec3 cross: (%.1f, %.1f, %.1f)", cross_v.x, cross_v.y, cross_v.z)
    print(buf)

    dot_v = a1.dot(a2)
    viperlib.snprintf(buf, 256, "Vec3 dot: %.1f", dot_v)
    print(buf)

    # chained: (a + b).dot(c)
    a3 = Vec3(1.0, 2.0, 3.0)
    a4 = Vec3(4.0, 5.0, 6.0)
    a5 = Vec3(7.0, 8.0, 9.0)
    chain_dot = (a3 + a4).dot(a5)
    viperlib.snprintf(buf, 256, "Vec3 chain dot: %.1f", chain_dot)
    print(buf)

    # chained: (a * 2.0 - b).cross(c)
    chain_cross = (a3 * 2.0 - a4).cross(a5)
    viperlib.snprintf(buf, 256, "Vec3 chain cross: (%.1f, %.1f, %.1f)", chain_cross.x, chain_cross.y, chain_cross.z)
    print(buf)

    # chained len_sq
    lsq = a3.len_sq()
    viperlib.snprintf(buf, 256, "Vec3 len_sq: %.1f", lsq)
    print(buf)
    testcheck.ok("Vec3 运算符重载测试完成")

    # === Dog/Cat virtual methods ===
    testcheck.section("Dog/Cat 虚方法")
    dog = Dog(1, int32(30))
    cat = Cat(2, int32(9))

    viperlib.snprintf(buf, 256, "Dog speak=%d bite=%d alive=%d", dog.speak(), dog.bite(), dog.is_alive())
    print(buf)
    viperlib.snprintf(buf, 256, "Cat speak=%d scratch=%d alive=%d", cat.speak(), cat.scratch(), cat.is_alive())
    print(buf)

    dog.take_damage(int32(40)).take_damage(int32(30))
    viperlib.snprintf(buf, 256, "Dog after 70dmg: health=%d alive=%d", dog.health, dog.is_alive())
    print(buf)

    cat.take_damage(int32(50))
    viperlib.snprintf(buf, 256, "Cat after 50dmg: health=%d alive=%d", cat.health, cat.is_alive())
    print(buf)
    testcheck.ok("Dog/Cat 虚方法测试完成")

    # === Transform nested composition (heap, chained calls) ===
    testcheck.section("Transform 嵌套组合")
    tr = Transform(10.0, 20.0, 30.0)
    tr.apply_scale(2.0, 3.0, 4.0)
    pos = tr.world_position()
    viperlib.snprintf(buf, 256, "Transform pos: (%.1f, %.1f, %.1f)", pos.x, pos.y, pos.z)
    print(buf)

    tr2 = Transform(5.0, 10.0, 15.0)
    tr2.apply_scale(2.0, 2.0, 2.0)
    pos2 = tr2.world_position()
    viperlib.snprintf(buf, 256, "Transform2 pos: (%.1f, %.1f, %.1f)", pos2.x, pos2.y, pos2.z)
    print(buf)
    testcheck.ok("Transform 嵌套组合测试完成")

    # === multilevel inheritance ===
    testcheck.section("多层继承")
    ec = ElectricCar(int32(120), int32(4), int32(80))
    viperlib.snprintf(buf, 256, "ECar speed=%d doors=%d battery=%d", ec.speed, ec.doors, ec.battery)
    print(buf)
    ec.charge()
    viperlib.snprintf(buf, 256, "ECar after charge: battery=%d", ec.battery)
    print(buf)
    spd = ec.move()
    viperlib.snprintf(buf, 256, "ECar move: speed=%d battery=%d", spd, ec.battery)
    print(buf)
    viperlib.snprintf(buf, 256, "ECar honk=%d running=%d", ec.honk(), ec.is_running())
    print(buf)
    testcheck.ok("多层继承测试完成")

    stdlib.free(buf)
    return testcheck.end()