import sys

op_idx = 0
opname_idx = 1
symbols = [
    ["+", "add"],
    ["-", "sub"],
    ["*", "mul"],
    ["/", "div"],
]

basic_types = [
    "f32",
    "f64",
    "i32",
    "i64",
]

name_idx = 0
member_idx = 1

vec_types = [
    ["v2", ["x", "y"]],
    ["v3", ["x", "y", "z"]],
    ["v4", ["x", "y", "z", "w"]],
]

rect_types = [
    ["r2", ["x0", "y0", "x1", "y1"]],
    ["r3", ["x0", "y0", "z0", "x1", "y1", "z1"]],
]

struct_types = vec_types + rect_types


# fd = open("mathx.gen.h", "w")
# sys.stdout = fd

# print("// auto generated using:", __file__)

# for bt in basic_types:
#     s = """
# typedef union v2f64_t v2f64_t;
# union v2f64_t {
#     struct { f64 x, y; };
#     f64 e[2];
# };

# typedef union v3f64_t v3f64_t;
# union v3f64_t {
#     struct { f64 x, y, z; };
#     struct { v2f64_t xy; };
#     struct { f64 _x0; v2f64_t zw; };
#     struct { f64 r, g, b; };
#     struct { f64 h, s, l; };
#     f64 e[3];
# };

# typedef union v4f64_t v4f64_t;
# union v4f64_t {
#     struct { f64 x, y, z, w; };
#     struct { v2f64_t xy; v2f64_t zw; };
#     struct { v3f64_t xyz; };
#     struct { f64 _x0; f64 yzw; };
#     struct { f64 r, g, b, a; };
#     struct { f64 h, s, l, _a; };
#     f64 e[4];
# };

# typedef union r1f64_t r1f64_t;
# union r1f64_t {
#     struct { f64 min, max; };
#     struct { f64 x0, x1; };
#     f64 e[2];
# };

# typedef union r2f64_t r2f64_t;
# union r2f64_t {
#     struct { v2f64_t min, max; };
#     struct { f64 x0, y0, x1, y1; };
#     v4f64_t e4;
#     f64 e[4];
# };

# typedef union r3f64_t r3f64_t;
# union r3f64_t {
#     struct { v3f64_t min, max; };
#     struct { f64 x0, y0, z0, x1, y1, z1; };
#     f64 e[6];
# };
#
#
# type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2,
#     .members = (type_member_t[]){
#         {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)},
#         {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)},
#     }
# };

# type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64_t), .count = 3,
#     .members = (type_member_t[]){
#         {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)},
#         {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)},
#         {s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)},
#     }
# };

# type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4,
#     .members = (type_member_t[]){
#         {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)},
#         {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)},
#         {s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)},
#         {s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)},
#     }
# };

# type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6,
#     .members = (type_member_t[]){
#         {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)},
#         {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)},
#         {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)},
#         {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)},
#         {s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)},
#         {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)},
#     }
# };

# type_member_t members__r2f64_t[] = {
#     {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)},
#     {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)},
#     {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)},
#     {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)},
# };
# DEFINE_STRUCT(r2f64_t);

# type_member_t members__r1f64_t[] = {
#     {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)},
#     {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)},
# };
# DEFINE_STRUCT(r1f64_t);
#     """
#     s = s.replace("f64", bt)
#     print(s)


fd = open("mathx.gen.c", "w")
sys.stdout = fd

print("// auto generated using:", __file__)

for basic_type in basic_types:
    for st in struct_types:
        type = f"{st[name_idx]}{basic_type}"
        typedef = f"{type}_t"
        members = st[member_idx]

        def members_as_func_params(members, basic_type):
            result = ""
            for i, m in enumerate(members):
                result += f"{basic_type} {m}"
                if i != len(members) - 1:
                    result += ", "
            return result

        print(f"""{type}_t {type}({members_as_func_params(members, basic_type)}) {{ return ({type}_t){{ {members_as_func_params(members, "")} }}; }}""")

        for sym in symbols:
            op = sym[op_idx]
            opname = sym[opname_idx]


            def op_str(members, op, skip_right = False):
                result = ""
                for i in range(len(members)):
                    mem = members[i]
                    if skip_right:
                        result += f"a.{mem} {op} b"
                    else:
                        result += f"a.{mem} {op} b.{mem}"

                    if i != len(members) - 1:
                        result += ", "
                return result



            print(f"{type}_t {type}_{opname}({type}_t a, {type}_t b) {{ return ({type}_t){{ {op_str(members, op)} }}; }}")
            print(f"{type}_t {type}_{opname}s({type}_t a, {basic_type} b) {{ return ({type}_t){{ {op_str(members, op, skip_right = True)} }}; }}")

for basic_type in basic_types:
    for i in range(len(rect_types)):
        vec_type = vec_types[i]
        rect_type = rect_types[i]

        vec_name = vec_type[name_idx] + basic_type
        vec_members = vec_type[member_idx]
        rect_name = rect_type[name_idx] + basic_type
        rect_members = rect_type[member_idx]

        print(f"{rect_name}_t {rect_name}_mindim({vec_name}_t pos, {vec_name}_t size) {{ return ({rect_name}_t){{ pos, {vec_name}_add(pos, size) }}; }}")
        print(f"{rect_name}_t {rect_name}_center_halfdim({vec_name}_t center, {vec_name}_t halfdim) {{ return ({rect_name}_t){{ {vec_name}_sub(center, halfdim), {vec_name}_add(center, halfdim) }}; }}")

for basic_type in basic_types:
    s = """
r2f64_t r2f64_cut_left(r2f64_t *r, f64 value) {
    f64 minx = r->min.x;
    r->min.x = MIN(r->min.x + value, r->max.x);
    return (r2f64_t){ .min = {.x = minx, .y = r->min.y}, .max = {.x = r->min.x, .y =r->max.y} };
}
r2f64_t r2f64_cut_right(r2f64_t *r, f64 value) {
    f64 maxx = r->max.x;
    r->max.x = MAX(r->min.x, r->max.x - value);
    return (r2f64_t){ .min = {.x = r->max.x, .y = r->min.y}, .max = {.x = maxx, .y = r->max.y} };
}
r2f64_t r2f64_cut_top(r2f64_t *r, f64 value) { /* Y is down */
    f64 miny = r->min.y;
    r->min.y = MIN(r->max.y, r->min.y + value);
    return (r2f64_t){ .min = {.x = r->min.x, .y = miny}, .max = {.x = r->max.x, .y = r->min.y} };
}
r2f64_t r2f64_cut_bottom(r2f64_t *r, f64 value) { /* Y is down */
    f64 maxy = r->max.y;
    r->max.y = MAX(r->min.y, r->max.y - value);
    return (r2f64_t){ .min = {.x = r->min.x, .y = r->max.y}, .max = {.x = r->max.x, .y = maxy} };
}

// get past left
r2f64_t r2f64_getp_left(const r2f64_t *rect, f64 value) {
    r2f64_t result = r2f64(rect->min.x - value, rect->min.y, rect->min.x, rect->max.y);
    return result;
}
r2f64_t r2f64_getp_right(const r2f64_t *rect, f64 value) {
    r2f64_t result = r2f64(rect->max.x, rect->min.y, rect->max.x + value, rect->max.y);
    return result;
}
r2f64_t r2f64_getp_bottom(const r2f64_t *rect, f64 value) {
    r2f64_t result = r2f64(rect->min.x, rect->max.y, rect->max.x, rect->max.y + value);
    return result;
}
r2f64_t r2f64_getp_top(const r2f64_t *rect, f64 value) {
    r2f64_t result = r2f64(rect->min.x, rect->min.y - value, rect->max.x, rect->min.y);
    return result;
}

r2f64_t r2f64_get_left(const r2f64_t *r, f64 value) {
    f64 minx = r->min.x;
    r2f64_t result = (r2f64_t){ .min = {.x = minx, .y = r->min.y}, .max = {.x = MIN(r->min.x + value, r->max.x), .y =r->max.y} };
    return result;
}
r2f64_t r2f64_get_right(const r2f64_t *r, f64 value) {
    f64 maxx = r->max.x;
    r2f64_t result = (r2f64_t){ .min = {.x = MAX(r->min.x, r->max.x - value), .y = r->min.y}, .max = {.x = maxx, .y = r->max.y} };
    return result;
}
r2f64_t r2f64_get_top(const r2f64_t *r, f64 value) { /* Y is down */
    f64 miny = r->min.y;
    r2f64_t result = (r2f64_t){ .min = {.x = r->min.x, .y = miny}, .max = {.x = r->max.x, .y = MIN(r->max.y, r->min.y + value)} };
    return result;
}
r2f64_t r2f64_get_bottom(const r2f64_t *r, f64 value) { /* Y is down */
    f64 maxy = r->max.y;
    r2f64_t result = (r2f64_t){ .min = {.x = r->min.x, .y = MAX(r->min.y, r->max.y - value)}, .max = {.x = r->max.x, .y = maxy} };
    return result;
}

r2f64_t r2f64_shrink(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_add(rect.min, value), v2f64_sub(rect.max, value) }; }
v2f64_t r2f64_get_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_get_size(r), 2)); }
b32 r2f64_contains(r2f64_t rec, v2f64_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
    """
    s = s.replace("r2f64", f"r2{basic_type}")
    s = s.replace("f64", basic_type)
    s = s.replace("v2f64", f"v2{basic_type}")
    print(s)

for at in basic_types:
    for bt in basic_types:
        if at == bt: continue
        for st in struct_types:
            atype = f"{st[name_idx]}{at}"
            btype = f"{st[name_idx]}{bt}"
            members = st[member_idx]

            def cast_members(members, type):
                result = ""
                for i in range(len(members)):
                    result += f"({type})v.{members[i]}"
                    if i != len(members) - 1:
                        result += ", "
                return result

            print(f"{btype}_t {atype}_to_{btype}({atype}_t v) {{ return ({btype}_t){{ {cast_members(members, bt)} }}; }}")