const math = std.math;

// Types
const Circle = struct { radius: f32 };
const Direction = enum { right, down_right, down, down_left, left, top_left, top, top_right };

const ColorCircle = struct { circle: Circle, color: rl.Color };

const Drawable = union(enum) { rect: rl.Rectangle, color_rect: ColorRectangle };

const Velocity = struct { x: f32, y: f32 };
const Orientation = struct { direction: Direction };
const Drawable = union(enum) {
    rect: rl.Rectangle,
    color_rect: ColorRectangle,
    color_circle: ColorCircle,
};

    const orientation = ecs.field(it, Orientation, 3).?;

    const entities = it.entities();

        var vel = rl.Vector2{ .x = 0, .y = 0 };

            pos[i].x -= 2;

            vel.x -= 2;

            pos[i].x += 2;

            vel.x += 2;

            pos[i].y -= 2;

            vel.y -= 2;

            pos[i].y += 2;

            vel.y += 2;
        }
        const x: i32 = @intFromFloat(math.sign(vel.x));
        const y: i32 = @intFromFloat(math.sign(vel.y));
        if (x == 1 and y == 0) {
            orientation[i].direction = Direction.right;
        } else if (x == 1 and y == 1) {
            orientation[i].direction = Direction.down_right;
        } else if (x == 0 and y == 1) {
            orientation[i].direction = Direction.down;
        } else if (x == -1 and y == 1) {
            orientation[i].direction = Direction.down_left;
        } else if (x == -1 and y == 0) {
            orientation[i].direction = Direction.left;
        } else if (x == -1 and y == -1) {
            orientation[i].direction = Direction.top_left;
        } else if (x == 0 and y == -1) {
            orientation[i].direction = Direction.top;
        } else if (x == 1 and y == -1) {
            orientation[i].direction = Direction.top_right;

        _ = ecs.set(it.world, entities[i], Velocity, .{
            .x = pos[i].x + vel.x,
            .y = pos[i].y + vel.y,
        });

fn move(it: *ecs.iter_t) callconv(.C) void {
    const pos = ecs.field(it, Position, 1).?;
    const vel = ecs.field(it, Velocity, 2).?;
    for (0..it.count()) |i| {
        pos[i].x = vel[i].x;
        pos[i].y = vel[i].y;
    }
}

pub fn polarToCartesian(r: f32, theta: f32) rl.Vector2 {
    const x = r * std.math.cos(theta);
    const y = r * std.math.sin(theta);
    return rl.Vector2{ .x = x, .y = y };
}

    const pos = ecs.field(it, Position, 1).?;

    const position = ecs.field(it, Position, 1).?;

    const orientation = ecs.field(it, Orientation, 3);

    const theta = std.math.pi / 4.0;

        const p = pos[i];

        const pos = position[i];

                    .x = d.x + p.x,
                    .y = d.y + p.y,

                    .x = d.x + pos.x,
                    .y = d.y + pos.y,

                    .x = d.rect.x + p.x,
                    .y = d.rect.y + p.y,

                    .x = d.rect.x + pos.x,
                    .y = d.rect.y + pos.y,

            },
            Drawable.color_circle => |d| {
                const p = rl.Vector2{
                    .x = pos.x + d.circle.radius,
                    .y = pos.y + d.circle.radius,
                };
                rl.DrawCircleV(p, d.circle.radius, d.color);
                if (orientation != null) {
                    const dir = orientation.?;
                    const cart = polarToCartesian(
                        d.circle.radius,
                        theta * @as(f32, @floatFromInt(@intFromEnum(dir[i].direction))),
                    );
                    const end = rl.Vector2{
                        .x = p.x + cart.x,
                        .y = p.y + cart.y,
                    };
                    rl.DrawLineV(
                        p,
                        end,
                        rl.BLACK,
                    );
                }

    ecs.COMPONENT(world, Velocity);
    ecs.COMPONENT(world, Orientation);

        system_desc.query.filter.terms[2] = .{ .id = ecs.id(Orientation) };

    };
    const move_system = sys: {
        var system_desc = ecs.system_desc_t{};
        system_desc.callback = move;
        system_desc.query.filter.terms[0] = .{ .id = ecs.id(Position) };
        system_desc.query.filter.terms[1] = .{ .id = ecs.id(Velocity) };
        system_desc.query.filter.terms[2] = .{ .id = ecs.id(CameraTarget), .oper = ecs.oper_kind_t.Optional };
        break :sys SYSTEM(world, "move", handle_input_system, &system_desc);

        _ = SYSTEM(world, "get_camera_target", handle_input_system, &system_desc);

        _ = SYSTEM(world, "get_camera_target", move_system, &system_desc);

        system_desc.query.filter.terms[2] = .{ .id = ecs.id(Foreground), .oper = ecs.oper_kind_t.Not };
        system_desc.query.filter.terms[3] = .{ .id = ecs.id(Background), .oper = ecs.oper_kind_t.Not };

        system_desc.query.filter.terms[2] = .{ .id = ecs.id(Orientation), .oper = ecs.oper_kind_t.Optional };
        system_desc.query.filter.terms[3] = .{ .id = ecs.id(Foreground), .oper = ecs.oper_kind_t.Not };
        system_desc.query.filter.terms[4] = .{ .id = ecs.id(Background), .oper = ecs.oper_kind_t.Not };

    _ = ecs.set(world, player, Drawable, .{
        .rect = rl.Rectangle{
            .x = 0,
            .y = 0,
            .width = 40,
            .height = 40,
        },
    });

    _ = ecs.set(world, player, Orientation, .{ .direction = Direction.right });
    _ = ecs.set(world, player, Drawable, .{ .color_circle = ColorCircle{
        .circle = Circle{ .radius = 20 },
        .color = rl.BLUE,
    } });

            draw_debug(game_state);

            // draw_debug(game_state);