// Leiden community detection
auto communities = leidenCommunityDetection(graph);

// Result: each vertex mapped to a community ID
// vertex 0 → community 3
// vertex 1 → community 0
// vertex 2 → community 3
// ...

struct CommunityFeatures {
    size_t num_nodes;
    size_t num_edges;
    double internal_density;     // edges / possible_edges
    double avg_degree;
    double degree_variance;      // normalized variance in degrees
    double hub_concentration;    // fraction of edges from top 10% nodes
    double modularity;           // community/subgraph modularity
    double clustering_coeff;     // local clustering coefficient (sampled)
    double avg_path_length;      // estimated average path length
    double diameter_estimate;    // estimated graph diameter
    double community_count;      // number of sub-communities
    double reorder_time;         // estimated reorder time (if known)
};

// bench/include/graphbrew/reorder/reorder_graphbrew.h
enum class GraphBrewClusterVariant {
    LEIDEN,      // Original Leiden library (igraph)
    GVE,         // GVE-Leiden CSR-native
    GVEOPT,      // Cache-optimized GVE
    GVEFAST,     // Single-pass GVE
    GVEOPTFAST,  // Cache-optimized single-pass
    RABBIT,      // RabbitOrder-based
    HUBCLUSTER   // Hub-clustering based
};

// bench/include/graphbrew/reorder/reorder_graphbrew.h
struct GraphBrewConfig {
    GraphBrewClusterVariant variant = GraphBrewClusterVariant::LEIDEN;
    int frequency = 10;           // Hub frequency threshold
    int intra_algo = 8;           // Algorithm ID for within-community reordering
    double resolution = -1.0;     // Leiden resolution (-1 = auto)
    int maxIterations = 30;       // Max Leiden iterations
    int maxPasses = 30;           // Max Leiden passes

    // Parse from command-line options string
    static GraphBrewConfig FromOptions(const std::string& options);
    
    // Convert to internal reordering options
    ReorderingOptions toInternalOptions() const;
    
    // Print configuration for debugging
    void print() const;
};

// Usage in builder.h:
GraphBrewConfig config = GraphBrewConfig::FromOptions("gve:10:8:1.0:30:30");
// → variant=GVE, frequency=10, intra_algo=8, resolution=1.0, etc.

// Unified entry point for GraphBrewOrder
void GenerateGraphBrewMappingUnified(
    const CSRGraph& g, pvector<NodeID_>& new_ids,
    const ReorderingOptions& opts);

// Sort communities by size (largest first)
// Rationale: largest communities benefit most from optimization
sort(communities.begin(), communities.end(), 
     [](auto& a, auto& b) { return a.size > b.size; });

// Default: RabbitOrder (algorithm 8 with csr variant)
// RabbitOrder has variants: csr (default), boost
// Can be changed via format string: -o 12:freq:algo:resolution
ReorderingAlgo algo = getReorderingAlgo(reorderingOptions[1].c_str());  // default: "8"

// Apply the selected algorithm to each community subgraph
GenerateMappingLocalEdgelist(g, edge_list, new_ids_sub, algo, ...);

// In ReorderCommunitySubgraphStandalone (reorder.h):
// If community has no internal edges (all edges go to other communities),
// skip reordering and assign nodes in original order
if (sub_edges.empty()) {
    for (NodeID_ node : nodes) {
        new_ids[node] = current_id++;
    }
    return;
}

// New vertex ID assignment
new_id = community_start_offset + position_within_community

// Example:
// Community 0 starts at offset 0, has 1000 vertices
// Community 1 starts at offset 1000, has 500 vertices
// Vertex 45 in Community 1 (position 23) gets ID: 1000 + 23 = 1023

// Dynamic threshold formula:
// min_size = max(ABSOLUTE_MIN, min(avg_community_size / FACTOR, sqrt(N)))
// Capped at MAX_THRESHOLD (2000)

size_t ComputeDynamicMinCommunitySize(size_t num_nodes, 
                                       size_t num_communities,
                                       size_t avg_community_size) {
    const size_t ABSOLUTE_MIN = 50;
    const size_t MAX_THRESHOLD = 2000;
    const size_t FACTOR = 4;
    
    size_t dynamic_threshold = std::max(ABSOLUTE_MIN,
        std::min(avg_community_size / FACTOR, 
                 static_cast<size_t>(std::sqrt(num_nodes))));
    
    return std::min(dynamic_threshold, MAX_THRESHOLD);
}

// Local reorder threshold = 2 × min_community_size (capped at 5000)
size_t ComputeDynamicLocalReorderThreshold(size_t num_nodes,
                                            size_t num_communities,
                                            size_t avg_community_size) {
    size_t min_size = ComputeDynamicMinCommunitySize(...);
    return std::min(min_size * 2, static_cast<size_t>(5000));
}

// Small communities grouped together
// Features computed for the entire group
// Algorithm selected via perceptron (AdaptiveOrder) or heuristic (GraphBrew)

// GraphBrewOrder: Leiden + per-community RabbitOrder
{GraphBrewOrder, {
    .bias = 0.6,
    .w_modularity = -0.25,    // better on low-mod graphs
    .w_log_nodes = 0.1,       // scales well
    .w_log_edges = 0.08,
    .w_density = -0.3,
    .w_avg_degree = 0.0,
    .w_degree_variance = 0.2,
    .w_hub_concentration = 0.1,
    .w_reorder_time = -0.5    // highest reorder cost
}}