// ============================================================================
// engine.c - 引擎核心实现
// ============================================================================

#include "engine.h"
#include "logger.h"
#include "timer.h"
#include "../Window/window.h"
#include "../Rendering/renderer.h"
#include "../Rendering/graphics_device.h"
#include "../include/engine_api.h"
#include <stdlib.h>
#include <Windows.h>

// 引擎实例 (单例)
static Engine g_engine = {0};

// 回调
static EngineUpdateCallback g_update_callback = NULL;
static EngineRenderCallback g_render_callback = NULL;
static EngineKeyCallback g_key_callback = NULL;
static EngineResizeCallback g_resize_callback = NULL;
static EngineMouseMoveCallback g_mouse_move_callback = NULL;
static EngineMouseButtonCallback g_mouse_button_callback = NULL;

// 内部函数
static void on_key(int key) {
    if (g_key_callback) {
        g_key_callback(&g_engine, key);
    }
    if (key == VK_ESCAPE) {
        engine_request_quit(&g_engine);
    }
}

static void on_resize(int width, int height) {
    if (g_resize_callback) {
        g_resize_callback(&g_engine, width, height);
    }
}

static void on_mouse_move(int x, int y) {
    if (g_mouse_move_callback) {
        g_mouse_move_callback(&g_engine, x, y);
    }
}

static void on_mouse_button(int button, int pressed) {
    if (g_mouse_button_callback) {
        g_mouse_button_callback(&g_engine, button, pressed);
    }
}

Engine* engine_create(void) {
    return &g_engine;
}

void engine_destroy(Engine* engine) {
    if (engine) {
        engine_shutdown(engine);
    }
}

int engine_init(Engine* engine, const EngineConfig* config) {
    if (engine->initialized) return 1;

    engine->config = *config;

    // 初始化日志
    logger_init("engine.log");
    LOG_INFO("Initializing MiMo Engine ASM...");

    // 初始化计时器
    timer_init();

    // 创建窗口
    engine->window = window_create(
        config->app_name,
        config->window_width,
        config->window_height,
        config->fullscreen
    );

    if (!engine->window) {
        LOG_ERROR("Failed to create window!");
        return 0;
    }

    // 设置回调
    window_set_key_callback(engine->window, on_key);
    window_set_resize_callback(engine->window, on_resize);
    window_set_mouse_move_callback(engine->window, on_mouse_move);
    window_set_mouse_button_callback(engine->window, on_mouse_button);

    LOG_INFO("Window created: %dx%d", config->window_width, config->window_height);

    // 创建 D3D11 图形设备
    engine->graphics_device = graphics_device_create();
    if (!graphics_device_init(engine->graphics_device,
                              window_get_handle(engine->window),
                              config->window_width,
                              config->window_height,
                              config->vsync)) {
        LOG_ERROR("Failed to initialize D3D11 graphics device!");
        window_destroy(engine->window);
        engine->window = NULL;
        return 0;
    }

    // 创建渲染器
    engine->renderer = renderer_create(engine->graphics_device);
    if (!engine->renderer) {
        LOG_ERROR("Failed to create renderer!");
        graphics_device_destroy(engine->graphics_device);
        engine->graphics_device = NULL;
        window_destroy(engine->window);
        engine->window = NULL;
        return 0;
    }

    LOG_INFO("Graphics device and renderer ready.");

    engine->initialized = 1;
    engine->running = 1;
    engine->frame_count = 0;

    LOG_INFO("MiMo Engine ASM initialized successfully.");
    return 1;
}

void engine_run(Engine* engine) {
    if (!engine->initialized) {
        LOG_ERROR("Engine not initialized!");
        return;
    }

    double fixed_dt = 1.0 / 60.0;  // 60Hz 固定时间步
    double accumulator = 0.0;
    double fps_timer = 0.0;
    int fps_frames = 0;
    int fps_display = 0;

    while (engine->running) {
        // 处理窗口消息
        if (!window_process_messages(engine->window)) {
            engine->running = 0;
            break;
        }

        // 更新计时
        timer_tick();
        engine->delta_time = timer_get_delta();
        engine->total_time += engine->delta_time;
        engine->frame_count++;

        // FPS 计算
        fps_timer += engine->delta_time;
        fps_frames++;
        if (fps_timer >= 1.0) {
            fps_display = fps_frames;
            fps_frames = 0;
            fps_timer -= 1.0;
        }

        // 固定时间步逻辑更新
        accumulator += engine->delta_time;
        while (accumulator >= fixed_dt) {
            if (g_update_callback) {
                g_update_callback(engine, fixed_dt);
            }
            accumulator -= fixed_dt;
        }

        // 渲染
        if (g_render_callback) {
            g_render_callback(engine);
        }

        // 存储 FPS 供外部读取
        engine->fps = fps_display;
    }
}

void engine_shutdown(Engine* engine) {
    if (!engine->initialized) return;

    LOG_INFO("Shutting down MiMo Engine ASM...");

    if (engine->renderer) {
        renderer_destroy(engine->renderer);
        engine->renderer = NULL;
    }

    if (engine->graphics_device) {
        graphics_device_destroy(engine->graphics_device);
        engine->graphics_device = NULL;
    }

    if (engine->window) {
        window_destroy(engine->window);
        engine->window = NULL;
    }

    logger_shutdown();
    engine->initialized = 0;
    engine->running = 0;
}

void engine_request_quit(Engine* engine) {
    engine->running = 0;
}

// 回调设置
void engine_set_update_callback(Engine* engine, EngineUpdateCallback callback) {
    g_update_callback = callback;
}

void engine_set_render_callback(Engine* engine, EngineRenderCallback callback) {
    g_render_callback = callback;
}

void engine_set_key_callback(Engine* engine, EngineKeyCallback callback) {
    g_key_callback = callback;
}

void engine_set_resize_callback(Engine* engine, EngineResizeCallback callback) {
    g_resize_callback = callback;
}

void engine_set_mouse_move_callback(Engine* engine, EngineMouseMoveCallback callback) {
    g_mouse_move_callback = callback;
}

void engine_set_mouse_button_callback(Engine* engine, EngineMouseButtonCallback callback) {
    g_mouse_button_callback = callback;
}

GraphicsDevice* engine_get_graphics_device(Engine* engine) {
    return engine ? engine->graphics_device : NULL;
}

Renderer* engine_get_renderer(Engine* engine) {
    return engine ? (Renderer*)engine->renderer : NULL;
}