void Window::draw(const TermBuffer& term_buffer) {
    auto& damaged_buf = term_buffer.get_damage_buffer();

    if (damaged_buf.empty()) {
        SDL_Delay(16);
        return;
    }
    cursor_pos_.x = 10;
    cursor_pos_.y = get_font_size().second / 2;

    decltype(auto) buffer = term_buffer.get_buffer();
    auto font_size = get_font_size();

    auto render_limit = get_window_size().second / get_font_size().second;
    // std::cout << render_limit << std::endl;

    SDL_SetRenderTarget(renderer_, backbuffer_);

    for (auto i : damaged_buf) {
        if (i < scroll_offset_ || i >= scroll_offset_ + render_limit) continue;

        int row_index = i - scroll_offset_;
        int row_y = row_index * font_size.second;
        SDL_Rect row_rect{0, row_y, width_, font_size.second};

        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
        SDL_RenderFillRect(renderer_, &row_rect);

        cursor_pos_.x = 10;
        cursor_pos_.y = row_y;

        for (auto cell : buffer[i]) {
            if (cell.codepoint == 0) cell.codepoint = ' ';
            auto* atlas = glyph_cache_->atlas();

            SDL_Rect src = glyph_cache_->get_or_create_glyph_pos(renderer_, font_, cell.codepoint);
            SDL_Rect glyph_rect{cursor_pos_.x, cursor_pos_.y, src.w, src.h};

            SDL_SetTextureColorMod(atlas, cell.fg_color.r, cell.fg_color.g, cell.fg_color.b);

            if (cell.bg_color != SDL_Color{0, 0, 0, 255}) {
                SDL_SetRenderDrawColor(renderer_, cell.bg_color.r, cell.bg_color.g, cell.bg_color.b, cell.bg_color.a);
                SDL_RenderFillRect(renderer_, &glyph_rect);
                SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
            }

            if (cell.is_underline()) {
                SDL_SetRenderDrawColor(renderer_, cell.fg_color.r, cell.fg_color.g, cell.fg_color.b, cell.fg_color.a);
                SDL_RenderDrawLine(renderer_, cursor_pos_.x, cursor_pos_.y + src.h - src.h / 5,
                                   cursor_pos_.x + src.w, cursor_pos_.y + src.h - src.h / 5);
            }

            if (cell.is_bold()) {
                SDL_SetTextureColorMod(atlas, 255, 255, 255);
            }

            if (cell.is_strikethrough()) {
                SDL_SetRenderDrawColor(renderer_, 255, 255, 255, 255);
                SDL_RenderDrawLine(renderer_, cursor_pos_.x, cursor_pos_.y + src.h / 2,
                                   cursor_pos_.x + src.w, cursor_pos_.y + src.h / 2);
            }

            SDL_RenderCopy(renderer_, atlas, &src, &glyph_rect);
            cursor_pos_.x += src.w;
        }
    }
    // auto [cursor_x, cursor_y] = term_buffer.get_cursor_pos();

    // const auto& row = buffer[cursor_y];
    // SDL_Rect cursor_rect{cursor_x * font_size.first + font_size.first, (cursor_y - (int)scroll_offset_) * font_size.second + font_size.second / 2, 10, font_size.second};
    // SDL_SetRenderDrawColor(renderer_, 255, 255, 255, 255);
    // SDL_RenderFillRect(renderer_, &cursor_rect);

    SDL_SetRenderTarget(renderer_, nullptr);
    for (auto i : damaged_buf) {
        auto row = i - scroll_offset_;
        std::cout << row << std::endl;
        SDL_Rect row_rect {0, (int)row * font_size.second, width_, font_size.second};
        SDL_RenderCopy(renderer_, backbuffer_, &row_rect, &row_rect);
    }

    SDL_RenderPresent(renderer_);
    should_render_ = false;

    damaged_buf.clear();
}