class Polars::LazyGroupBy

def agg(*aggs, **named_aggs)
  rbexprs = Utils.parse_into_list_of_expressions(*aggs, **named_aggs)
  Utils.wrap_ldf(@lgb.agg(rbexprs))
end

def all
  agg(F.all)
end

def first(ignore_nulls: false)
  agg(F.all.first(ignore_nulls: ignore_nulls))
end

def having(*predicates)
  rbexprs = Utils.parse_into_list_of_expressions(*predicates)
  @lgb = @lgb.having(rbexprs)
  self
end

def head(n = 5)
  Utils.wrap_ldf(@lgb.head(n))
end

def initialize(lgb)
  @lgb = lgb
end

def last(ignore_nulls: false)
  agg(F.all.last(ignore_nulls: ignore_nulls))
end

def len(name: nil)
  len_expr = F.len
  if !name.nil?
    len_expr = len_expr.alias(name)
  end
  agg(len_expr)
end

def map_groups(
  schema,
  &function
)
  Utils.wrap_ldf(
    @lgb.map_groups(->(df) { function.(Utils.wrap_df(df))._df }, schema)
  )
end

def max
  agg(F.all.max)
end

def mean
  agg(F.all.mean)
end

def median
  agg(F.all.median)
end

def min
  agg(F.all.min)
end

def n_unique
  agg(F.all.n_unique)
end

def quantile(quantile, interpolation: "nearest")
  agg(F.all.quantile(quantile, interpolation: interpolation))
end

def sum
  agg(F.all.sum)
end

def tail(n = 5)
  Utils.wrap_ldf(@lgb.tail(n))
end