#include "../Engine/Core/engine.h"
#include "../Engine/Core/logger.h"
#include "../Engine/Core/timer.h"
#include "../Engine/Window/window.h"
#include "../Engine/Rendering/graphics_device.h"
#include "../Engine/Rendering/shader.h"
#include "../Engine/Rendering/mesh.h"
#include "../Engine/Rendering/camera.h"
#include "../Engine/include/engine_api.h"
#include "../Engine/ASM/math_c_fallback.h"
#include <math.h>
#include <stdio.h>

static GraphicsDevice* g_dev = NULL;
static Shader* g_shader = NULL;
static Mesh* g_cube = NULL;
static Camera g_camera;
static float g_angle = 0.0f;

static void mat4_transpose(const Mat4* in, Mat4* out) {
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
            out->m[i][j] = in->m[j][i];
}

static void on_render(Engine* engine) {
    if (!g_dev || !g_shader || !g_cube) return;

    float w = (float)window_get_width(engine->window);
    float h = (float)window_get_height(engine->window);

    graphics_device_clear(g_dev, 0.15f, 0.15f, 0.2f, 1.0f);

    g_dev->context->lpVtbl->IASetPrimitiveTopology(g_dev->context, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    Mat4 model, wvp, wvp_t;
    mat4_rotate_y(g_angle, &model);
    Mat4* view = (Mat4*)camera_get_view(&g_camera);
    Mat4* proj = (Mat4*)camera_get_projection(&g_camera);

    Mat4 vp;
    mat4_multiply(view, proj, &vp);
    mat4_multiply(&model, &vp, &wvp);
    mat4_transpose(&wvp, &wvp_t);

    shader_bind(g_shader, g_dev->context);
    shader_set_matrix(g_shader, g_dev->context, (float*)&wvp_t);

    ID3D11DepthStencilView* dsv = g_dev->depth_stencil;
    g_dev->context->lpVtbl->OMSetRenderTargets(g_dev->context, 1, &g_dev->render_target, dsv);
    D3D11_VIEWPORT vp2 = {0};
    vp2.Width = w; vp2.Height = h; vp2.MaxDepth = 1.0f;
    g_dev->context->lpVtbl->RSSetViewports(g_dev->context, 1, &vp2);
    g_dev->context->lpVtbl->RSSetState(g_dev->context, NULL);

    mesh_draw(g_cube, g_dev->context);
    graphics_device_present(g_dev);

    g_angle += 0.02f;
}

static void on_key(Engine* engine, int key) {
    if (key == VK_ESCAPE) engine_request_quit(engine);
}

static void on_resize(Engine* engine, int width, int height) {
    if (g_dev && width > 0 && height > 0) {
        graphics_device_resize(g_dev, width, height);
        g_camera.aspect = (float)width / (float)height;
        g_camera.dirty = 1;
    }
}

int main(int argc, char* argv[]) {
    (void)argc; (void)argv;

    EngineConfig config = engine_default_config();
    config.app_name = "MiMo Engine - Cube Demo";
    config.vsync = 0;
    config.window_width = 1280;
    config.window_height = 720;

    Engine* engine = engine_create();
    if (!engine_init(engine, &config)) {
        LOG_FATAL("Engine init failed");
        return -1;
    }

    g_dev = graphics_device_create();
    if (!graphics_device_init(g_dev, window_get_handle(engine->window), config.window_width, config.window_height, 0)) {
        LOG_FATAL("D3D11 init failed");
        return -1;
    }
    LOG_INFO("D3D11 device ready");

    g_shader = shader_create();
    if (!shader_compile(g_shader, g_dev->device, NULL, NULL, 0, 0)) {
        LOG_FATAL("Shader compile failed");
        return -1;
    }
    LOG_INFO("Shader compiled");

    g_cube = mesh_create_cube(g_dev->device);
    LOG_INFO("Cube mesh created");

    float aspect = (float)config.window_width / (float)config.window_height;
    g_camera = camera_perspective(1.0472f, aspect, 0.1f, 100.0f);
    g_camera.position = (Vec3){0, 1.5f, -4.0f};
    g_camera.target = (Vec3){0, 0, 0};
    g_camera.dirty = 1;

    engine_set_render_callback(engine, on_render);
    engine_set_key_callback(engine, on_key);
    engine_set_resize_callback(engine, on_resize);

    LOG_INFO("Running cube demo...");
    engine_run(engine);

    mesh_destroy(g_cube);
    shader_destroy(g_shader);
    graphics_device_destroy(g_dev);
    engine_shutdown(engine);
    return 0;
}