class Polars::ListExpr

def [](item)
  get(item)
end

def agg(expr)
  Utils.wrap_expr(_rbexpr.list_agg(expr._rbexpr))
end

def all
  Utils.wrap_expr(_rbexpr.list_all)
end

def any
  Utils.wrap_expr(_rbexpr.list_any)
end

def arg_max
  Utils.wrap_expr(_rbexpr.list_arg_max)
end

def arg_min
  Utils.wrap_expr(_rbexpr.list_arg_min)
end

def concat(other)
  if other.is_a?(::Array) && ![Expr, String, Series].any? { |c| other[0].is_a?(c) }
    return concat(Series.new([other]))
  end
  if !other.is_a?(::Array)
    other_list = [other]
  else
    other_list = other.dup
  end
  other_list.insert(0, Utils.wrap_expr(_rbexpr))
  Polars.concat_list(other_list)
end

def contains(item, nulls_equal: true)
  Utils.wrap_expr(_rbexpr.list_contains(Utils.parse_into_expression(item), nulls_equal))
end

def count_matches(element)
  Utils.wrap_expr(_rbexpr.list_count_matches(Utils.parse_into_expression(element)))
end

def diff(n: 1, null_behavior: "ignore")
  Utils.wrap_expr(_rbexpr.list_diff(n, null_behavior))
end

def drop_nulls
  Utils.wrap_expr(_rbexpr.list_drop_nulls)
end

def eval(expr)
  Utils.wrap_expr(_rbexpr.list_eval(expr._rbexpr))
end

def explode(empty_as_null: true, keep_nulls: true)
  Utils.wrap_expr(_rbexpr.explode(empty_as_null, keep_nulls))
end

def filter(predicate)
  Utils.wrap_expr(_rbexpr.list_filter(predicate._rbexpr))
end

def first
  get(0, null_on_oob: true)
end

def gather(indices, null_on_oob: false)
  indices = Utils.parse_into_expression(indices)
  Utils.wrap_expr(_rbexpr.list_gather(indices, null_on_oob))
end

def gather_every(
  n,
  offset = 0
)
  n = Utils.parse_into_expression(n)
  offset = Utils.parse_into_expression(offset)
  Utils.wrap_expr(_rbexpr.list_gather_every(n, offset))
end

def get(index, null_on_oob: false)
  index = Utils.parse_into_expression(index)
  Utils.wrap_expr(_rbexpr.list_get(index, null_on_oob))
end

def head(n = 5)
  slice(0, n)
end

def initialize(expr)
  self._rbexpr = expr._rbexpr
end

def item(allow_empty: false)
  agg(F.element.item(allow_empty: allow_empty))
end

def join(separator, ignore_nulls: true)
  separator = Utils.parse_into_expression(separator, str_as_lit: true)
  Utils.wrap_expr(_rbexpr.list_join(separator, ignore_nulls))
end

def last
  get(-1, null_on_oob: true)
end

def len
  Utils.wrap_expr(_rbexpr.list_len)
end

def max
  Utils.wrap_expr(_rbexpr.list_max)
end

def mean
  Utils.wrap_expr(_rbexpr.list_mean)
end

def median
  Utils.wrap_expr(_rbexpr.list_median)
end

def min
  Utils.wrap_expr(_rbexpr.list_min)
end

def n_unique
  Utils.wrap_expr(_rbexpr.list_n_unique)
end

def reverse
  Utils.wrap_expr(_rbexpr.list_reverse)
end

def sample(n: nil, fraction: nil, with_replacement: false, shuffle: false, seed: nil)
  if !n.nil? && !fraction.nil?
    msg = "cannot specify both `n` and `fraction`"
    raise ArgumentError, msg
  end
  if !fraction.nil?
    fraction = Utils.parse_into_expression(fraction)
    return Utils.wrap_expr(
      _rbexpr.list_sample_fraction(
        fraction, with_replacement, shuffle, seed
      )
    )
  end
  n = 1 if n.nil?
  n = Utils.parse_into_expression(n)
  Utils.wrap_expr(_rbexpr.list_sample_n(n, with_replacement, shuffle, seed))
end

def set_difference(other)
  if other.respond_to?(:each)
    if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
      other = other.to_a
    end
    other = F.lit(other)._rbexpr
  else
    other = Utils.parse_into_expression(other)
  end
  Utils.wrap_expr(_rbexpr.list_set_operation(other, "difference"))
end

def set_intersection(other)
  if other.respond_to?(:each)
    if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
      other = other.to_a
    end
    other = F.lit(other)._rbexpr
  else
    other = Utils.parse_into_expression(other)
  end
  Utils.wrap_expr(_rbexpr.list_set_operation(other, "intersection"))
end

def set_symmetric_difference(other)
  if other.respond_to?(:each)
    if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
      other = other.to_a
    end
    other = F.lit(other)._rbexpr
  else
    other = Utils.parse_into_expression(other)
  end
  Utils.wrap_expr(_rbexpr.list_set_operation(other, "symmetric_difference"))
end

def set_union(other)
  if other.respond_to?(:each)
    if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
      other = other.to_a
    end
    other = F.lit(other)._rbexpr
  else
    other = Utils.parse_into_expression(other)
  end
  Utils.wrap_expr(_rbexpr.list_set_operation(other, "union"))
end

def shift(n = 1)
  n = Utils.parse_into_expression(n)
  Utils.wrap_expr(_rbexpr.list_shift(n))
end

def slice(offset, length = nil)
  offset = Utils.parse_into_expression(offset, str_as_lit: false)
  length = Utils.parse_into_expression(length, str_as_lit: false)
  Utils.wrap_expr(_rbexpr.list_slice(offset, length))
end

def sort(descending: false, nulls_last: false)
  Utils.wrap_expr(_rbexpr.list_sort(descending, nulls_last))
end

def std(ddof: 1)
  Utils.wrap_expr(_rbexpr.list_std(ddof))
end

def sum
  Utils.wrap_expr(_rbexpr.list_sum)
end

def tail(n = 5)
  n = Utils.parse_into_expression(n)
  Utils.wrap_expr(_rbexpr.list_tail(n))
end

def to_array(width)
  Utils.wrap_expr(_rbexpr.list_to_array(width))
end

def to_struct(n_field_strategy: nil, fields: nil, upper_bound: nil)
  if !fields.is_a?(::Array)
    if fields.nil?
      fields = upper_bound.times.map { |i| "field_#{i}" }
    else
      fields = upper_bound.times.map { |i| fields.(i) }
    end
  end
  Utils.wrap_expr(_rbexpr.list_to_struct(fields))
end

def unique(maintain_order: false)
  Utils.wrap_expr(_rbexpr.list_unique(maintain_order))
end

def var(ddof: 1)
  Utils.wrap_expr(_rbexpr.list_var(ddof))
end