#include "PlayerRenderer.hpp"
#include "../../net/NetworkManager.hpp"

PlayerRenderer::PlayerRenderer() {
    init();
}

PlayerRenderer::~PlayerRenderer() {
    // Unload textures
    for (auto& [color, texture] : playerTextures) {
        UnloadTexture(texture);
    }

    // Unload models
    UnloadModel(localPlayerModel);
    for (auto& [id, model] : remotePlayerModels) {
        UnloadModel(model);
    }
}

void PlayerRenderer::init() {
    // Load all player color textures
    playerTextures["red"] = LoadTexture("../assets/textures/red.png");
    playerTextures["green"] = LoadTexture("../assets/textures/green.png");
    playerTextures["orange"] = LoadTexture("../assets/textures/orange.png");
    playerTextures["purple"] = LoadTexture("../assets/textures/purple.png");
    playerTextures["white"] = LoadTexture("../assets/textures/white.png");

    // Create local player model
    auto cubeMesh = GenMeshCube(1.0f, 2.0f, 1.0f);
    localPlayerModel = LoadModelFromMesh(cubeMesh);
}

void PlayerRenderer::renderLocalPlayer(RenderContext& ctx, const Vector3& position, const std::string& color) {
    // Set texture based on player color
    if (playerTextures.count(color) > 0) {
        localPlayerModel.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = playerTextures[color];
    }

    // Submit to render context
    ctx.submitModel(localPlayerModel, position, 1.0f, WHITE, RenderContext::RenderLayer::ENTITIES);
}

void PlayerRenderer::renderRemotePlayers(RenderContext& ctx,
                                        const std::unordered_map<uint32_t, RemotePlayer>& players) {
    for (const auto& [id, player] : players) {
        // Ensure model exists for this player
        ensurePlayerModel(id);

        // Update texture based on player color
        if (remotePlayerModels.count(id) > 0 && playerTextures.count(player.color) > 0) {
            remotePlayerModels[id].materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = playerTextures[player.color];

            // Submit to render context
            ctx.submitModel(remotePlayerModels[id], player.position, 1.0f, WHITE,
                          RenderContext::RenderLayer::ENTITIES);
        }
    }
}

void PlayerRenderer::ensurePlayerModel(uint32_t playerId) {
    if (remotePlayerModels.find(playerId) == remotePlayerModels.end()) {
        // Create new model for this player
        auto cubeMesh = GenMeshCube(1.0f, 2.0f, 1.0f);
        remotePlayerModels[playerId] = LoadModelFromMesh(cubeMesh);
    }
}

void PlayerRenderer::removePlayerModel(uint32_t playerId) {
    auto it = remotePlayerModels.find(playerId);
    if (it != remotePlayerModels.end()) {
        UnloadModel(it->second);
        remotePlayerModels.erase(it);
    }
}

void PlayerRenderer::cleanupDisconnectedPlayers(const std::unordered_map<uint32_t, RemotePlayer>& currentPlayers) {
    // Remove models for players who are no longer connected
    for (auto it = remotePlayerModels.begin(); it != remotePlayerModels.end();) {
        if (currentPlayers.find(it->first) == currentPlayers.end()) {
            UnloadModel(it->second);
            it = remotePlayerModels.erase(it);
        } else {
            ++it;
        }
    }
}

Texture2D PlayerRenderer::getPlayerTexture(const std::string& color) const {
    auto it = playerTextures.find(color);
    if (it != playerTextures.end()) {
        return it->second;
    }
    // Return a default texture or handle error
    return Texture2D{};
}