ex_polars

defmodule ExPolars.Native do
  @moduledoc """
  Documentation for `Native`.
  """

  use Rustler, otp_app: :ex_polars, crate: :expolars

  defstruct [:inner]

  def df_read_csv(
        _filename,
        _infer_schema_length \\ 100,
        _batch_size \\ 64,
        _has_header \\ true,
        _ignore_errors \\ false,
        _stop_after_n_rows \\ nil,
        _skip_rows \\ 0,
        _projection \\ nil,
        _sep \\ ",",
        _rechunk \\ true,
        _columns \\ nil,
        _encoding \\ "utf8"
      ),
      do: err()

  def df_read_parquet(_filename), do: err()
  def df_read_json(_filename, _type), do: err()

  def df_to_csv(_df, _batch_size \\ 100_000, _has_headers \\ true, _delimiter \\ ?,),
    do: err()

  def df_to_csv_file(
        _df,
        _filename,
        _batch_size \\ 100_000,
        _has_headers \\ true,
        _delimiter \\ ?,
      ),
      do: err()

  def df_as_str(_df), do: err()

  def df_add(_df, _s), do: err()
  def df_sub(_df, _s), do: err()
  def df_div(_df, _s), do: err()
  def df_mul(_df, _s), do: err()
  def df_rem(_df, _s), do: err()
  def df_sample_n(_df, _n, _with_replacement), do: err()
  def df_sample_frac(_df, _f, _with_replacement), do: err()
  def df_rechunk(_df), do: err()
  def df_fill_none(_df, _strategy), do: err()
  def df_join(_df, _other, _left_on, _right_on, _how), do: err()
  def df_get_columns(_df), do: err()
  def df_columns(_def), do: err()
  def df_set_column_names(_df, _names), do: err()
  def df_dtypes(_df), do: err()
  def df_n_chunks(_df), do: err()
  def df_shape(_df), do: err()
  def df_height(_df), do: err()
  def df_width(_df), do: err()
  def df_hstack_mut(_df, _cols), do: err()
  def df_hstack(_df, _cols), do: err()
  def df_vstack(_df, _other), do: err()
  def df_drop_in_place(_df, _name), do: err()
  def df_drop_nulls(_df, _subset), do: err()
  def df_drop(_df, _name), do: err()
  def df_select_at_idx(_df, _idx), do: err()
  def df_find_idx_by_name(_df, _name), do: err()
  def df_column(_df, _name), do: err()
  def df_select(_df, _selection), do: err()
  def df_filter(_df, _mask), do: err()
  def df_take(_df, _indices), do: err()
  def df_take_with_series(_df, _indices), do: err()
  def df_sort_new(_df, _by_column, _reverse), do: err()
  def df_sort_in_place(_df, _by_column, _reverse), do: err()
  def df_replace(_df, _col, _new_col), do: err()
  def df_replace_at_idx(_df, _index, _new_col), do: err()
  def df_insert_at_idx(_df, _index, _new_col), do: err()
  def df_slice(_df, _offset, _length), do: err()
  def df_head(_df, _length \\ 5), do: err()
  def df_tail(_df, _length \\ 5), do: err()
  def df_is_unique(_df), do: err()
  def df_is_duplicated(_df), do: err()
  def df_frame_equal(_df, _other, _null_equal \\ false), do: err()
  def df_groupby(_df, _by, _sel, _agg), do: err()
  def df_groupby_agg(_df, _by, _column_to_agg), do: err()
  def df_groupby_quantile(_df, _by, _sel, _quant), do: err()
  def df_pivot(_df, _by, _pivot_column, _values_column, _agg), do: err()
  def df_clone(_df), do: err()
  def df_explode(_df, _cols), do: err()
  def df_melt(_df, _id_vars, _value_vars), do: err()
  def df_shift(_df, _periods), do: err()
  def df_drop_duplicates(_df, _maintain_order \\ true, _subset \\ nil), do: err()
  def df_max(_df), do: err()
  def df_min(_df), do: err()
  def df_sum(_df), do: err()
  def df_mean(_df), do: err()
  def df_stdev(_df), do: err()
  def df_var(_df), do: err()
  def df_median(_df), do: err()
  def df_quantile(_df, _quant), do: err()
  def df_to_dummies(_df), do: err()

  # Series
  def s_as_str(_s), do: err()
  def s_new_i8(_name, _val), do: err()
  def s_new_i16(_name, _val), do: err()
  def s_new_i32(_name, _val), do: err()
  def s_new_i64(_name, _val), do: err()
  def s_new_bool(_name, _val), do: err()
  def s_new_u8(_name, _val), do: err()
  def s_new_u16(_name, _val), do: err()
  def s_new_u32(_name, _val), do: err()
  def s_new_u64(_name, _val), do: err()
  def s_new_date32(_name, _val), do: err()
  def s_new_date64(_name, _val), do: err()
  def s_new_duration_ns(_name, _val), do: err()
  def s_new_f32(_name, _val), do: err()
  def s_new_f64(_name, _val), do: err()
  def s_parse_date32_from_str_slice(_name, _val, _fmt), do: err()
  def s_new_str(_name, _val), do: err()
  def s_rechunk(_s), do: err()
  def s_chunk_lengths(_s), do: err()
  def s_name(_s), do: err()
  def s_rename(_s, _name), do: err()
  def s_dtype(_s), do: err()
  def s_n_chunks(_s), do: err()
  def s_limit(_s, _num_elem), do: err()
  def s_slice(_s, _offset, _length), do: err()
  def s_append(_s, _other), do: err()
  def s_filter(_s, _filter), do: err()
  def s_add(_s, _other), do: err()
  def s_sub(_s, _other), do: err()
  def s_mul(_s, _other), do: err()
  def s_div(_s, _other), do: err()
  def s_head(_s, _length), do: err()
  def s_tail(_s, _length), do: err()
  def s_sort(_s, _reverse), do: err()
  def s_argsort(_s, _reverse), do: err()
  def s_unique(_s), do: err()
  def s_value_counts(_s), do: err()
  def s_arg_unique(_s), do: err()
  def s_take(_s, _indeces), do: err()
  def s_take_with_series(_s, _indeces), do: err()
  def s_null_count(_s), do: err()
  def s_is_null(_s), do: err()
  def s_is_not_null(_s), do: err()
  def s_is_unique(_s), do: err()
  def s_arg_true(_s), do: err()
  def s_sample_n(_s, _n, _with_replacement), do: err()
  def s_sample_frac(_s, _frac, _with_replacement), do: err()
  def s_is_duplicated(_s), do: err()
  def s_explode(_s), do: err()
  def s_take_every(_s, _n), do: err()
  def s_series_equal(_s, _other, _null_equal \\ false), do: err()
  def s_eq(_s, _rhs), do: err()
  def s_neq(_s, _rhs), do: err()
  def s_gt(_s, _rhs), do: err()
  def s_gt_eq(_s, _rhs), do: err()
  def s_lt(_s, _rhs), do: err()
  def s_lt_eq(_s, _rhs), do: err()
  def s_not(_s), do: err()
  def s_len(_s), do: err()
  def s_drop_nulls(_s), do: err()
  def s_fill_none(_s, _strategy), do: err()
  def s_clone(_s), do: err()
  def s_shift(_s, _periods), do: err()
  def s_zip_with(_s, _mask, _other), do: err()
  def s_str_lengths(_s), do: err()
  def s_str_contains(_s, _pat), do: err()
  def s_str_replace(_s, _pat, _val), do: err()
  def s_str_replace_all(_s, _pat, _val), do: err()
  def s_str_to_uppercase(_s), do: err()
  def s_str_to_lowercase(_s), do: err()
  def s_str_parse_date32(_s, _fmt), do: err()
  def s_str_parse_date64(_s, _fmt), do: err()
  def s_datetime_str_fmt(_s, _fmt), do: err()
  def s_as_duration(_s), do: err()
  def s_to_dummies(_s), do: err()
  def s_get_list(_s, _index), do: err()
  def s_rolling_sum(_s, _window_size, _weight, _ignore_null), do: err()
  def s_rolling_mean(_s, _window_size, _weight, _ignore_null), do: err()
  def s_rolling_max(_s, _window_size, _weight, _ignore_null), do: err()
  def s_rolling_min(_s, _window_size, _weight, _ignore_null), do: err()
  def s_year(_s), do: err()
  def s_month(_s), do: err()
  def s_day(_s), do: err()
  def s_ordinal_day(_s), do: err()
  def s_hour(_s), do: err()
  def s_minute(_s), do: err()
  def s_second(_s), do: err()
  def s_nanosecond(_s), do: err()
  def s_set_with_mask_str(_s, _filter, _value), do: err()
  def s_set_with_mask_f64(_s, _filter, _value), do: err()
  def s_set_with_mask_f32(_s, _filter, _value), do: err()
  def s_set_with_mask_u8(_s, _filter, _value), do: err()
  def s_set_with_mask_u16(_s, _filter, _value), do: err()
  def s_set_with_mask_u32(_s, _filter, _value), do: err()
  def s_set_with_mask_u64(_s, _filter, _value), do: err()
  def s_set_with_mask_i8(_s, _filter, _value), do: err()
  def s_set_with_mask_i16(_s, _filter, _value), do: err()
  def s_set_with_mask_i32(_s, _filter, _value), do: err()
  def s_set_with_mask_i64(_s, _filter, _value), do: err()
  def s_get_f32(_s, _index), do: err()
  def s_get_f64(_s, _index), do: err()
  def s_get_u8(_s, _index), do: err()
  def s_get_u16(_s, _index), do: err()
  def s_get_u32(_s, _index), do: err()
  def s_get_u64(_s, _index), do: err()
  def s_get_i8(_s, _index), do: err()
  def s_get_i16(_s, _index), do: err()
  def s_get_i32(_s, _index), do: err()
  def s_get_i64(_s, _index), do: err()
  def s_get_str(_s, _index), do: err()
  def s_get_date32(_s, _index), do: err()
  def s_get_date64(_s, _index), do: err()
  def s_cast_u8(_s), do: err()
  def s_cast_u16(_s), do: err()
  def s_cast_u32(_s), do: err()
  def s_cast_u64(_s), do: err()
  def s_cast_i8(_s), do: err()
  def s_cast_i16(_s), do: err()
  def s_cast_i32(_s), do: err()
  def s_cast_i64(_s), do: err()
  def s_cast_f32(_s), do: err()
  def s_cast_f64(_s), do: err()
  def s_cast_date32(_s), do: err()
  def s_cast_date64(_s), do: err()
  def s_cast_time64ns(_s), do: err()
  def s_cast_duration_ns(_s), do: err()
  def s_cast_str(_s), do: err()
  def s_add_i64(_s, _other), do: err()
  def s_sub_i64(_s, _other), do: err()
  def s_mul_i64(_s, _other), do: err()
  def s_div_i64(_s, _other), do: err()
  def s_add_f64(_s, _other), do: err()
  def s_sub_f64(_s, _other), do: err()
  def s_mul_f64(_s, _other), do: err()
  def s_div_f64(_s, _other), do: err()
  def s_add_i64_rhs(_s, _other), do: err()
  def s_sub_i64_rhs(_s, _other), do: err()
  def s_mul_i64_rhs(_s, _other), do: err()
  def s_div_i64_rhs(_s, _other), do: err()
  def s_add_f64_rhs(_s, _other), do: err()
  def s_sub_f64_rhs(_s, _other), do: err()
  def s_mul_f64_rhs(_s, _other), do: err()
  def s_div_f64_rhs(_s, _other), do: err()
  def s_sum_u8(_s), do: err()
  def s_sum_u16(_s), do: err()
  def s_sum_u32(_s), do: err()
  def s_sum_u64(_s), do: err()
  def s_sum_i8(_s), do: err()
  def s_sum_i16(_s), do: err()
  def s_sum_i32(_s), do: err()
  def s_sum_i64(_s), do: err()
  def s_sum_f32(_s), do: err()
  def s_sum_f64(_s), do: err()

  def s_min_u8(_s), do: err()
  def s_min_u16(_s), do: err()
  def s_min_u32(_s), do: err()
  def s_min_u64(_s), do: err()
  def s_min_i8(_s), do: err()
  def s_min_i16(_s), do: err()
  def s_min_i32(_s), do: err()
  def s_min_i64(_s), do: err()
  def s_min_f32(_s), do: err()
  def s_min_f64(_s), do: err()

  def s_max_u8(_s), do: err()
  def s_max_u16(_s), do: err()
  def s_max_u32(_s), do: err()
  def s_max_u64(_s), do: err()
  def s_max_i8(_s), do: err()
  def s_max_i16(_s), do: err()
  def s_max_i32(_s), do: err()
  def s_max_i64(_s), do: err()
  def s_max_f32(_s), do: err()
  def s_max_f64(_s), do: err()

  def s_mean_u8(_s), do: err()
  def s_mean_u16(_s), do: err()
  def s_mean_u32(_s), do: err()
  def s_mean_u64(_s), do: err()
  def s_mean_i8(_s), do: err()
  def s_mean_i16(_s), do: err()
  def s_mean_i32(_s), do: err()
  def s_mean_i64(_s), do: err()
  def s_mean_f32(_s), do: err()
  def s_mean_f64(_s), do: err()

  def s_eq_u8(_s, _rhs), do: err()
  def s_neq_u8(_s, _rhs), do: err()
  def s_gt_u8(_s, _rhs), do: err()
  def s_lt_u8(_s, _rhs), do: err()
  def s_gt_eq_u8(_s, _rhs), do: err()
  def s_lt_eq_u8(_s, _rhs), do: err()

  def s_eq_u16(_s, _rhs), do: err()
  def s_neq_u16(_s, _rhs), do: err()
  def s_gt_u16(_s, _rhs), do: err()
  def s_lt_u16(_s, _rhs), do: err()
  def s_gt_eq_u16(_s, _rhs), do: err()
  def s_lt_eq_u16(_s, _rhs), do: err()

  def s_eq_u32(_s, _rhs), do: err()
  def s_neq_u32(_s, _rhs), do: err()
  def s_gt_u32(_s, _rhs), do: err()
  def s_lt_u32(_s, _rhs), do: err()
  def s_gt_eq_u32(_s, _rhs), do: err()
  def s_lt_eq_u32(_s, _rhs), do: err()

  def s_eq_u64(_s, _rhs), do: err()
  def s_neq_u64(_s, _rhs), do: err()
  def s_gt_u64(_s, _rhs), do: err()
  def s_lt_u64(_s, _rhs), do: err()
  def s_gt_eq_u64(_s, _rhs), do: err()
  def s_lt_eq_u64(_s, _rhs), do: err()

  def s_eq_i8(_s, _rhs), do: err()
  def s_neq_i8(_s, _rhs), do: err()
  def s_gt_i8(_s, _rhs), do: err()
  def s_lt_i8(_s, _rhs), do: err()
  def s_gt_eq_i8(_s, _rhs), do: err()
  def s_lt_eq_i8(_s, _rhs), do: err()

  def s_eq_i16(_s, _rhs), do: err()
  def s_neq_i16(_s, _rhs), do: err()
  def s_gt_i16(_s, _rhs), do: err()
  def s_lt_i16(_s, _rhs), do: err()
  def s_gt_eq_i16(_s, _rhs), do: err()
  def s_lt_eq_i16(_s, _rhs), do: err()

  def s_eq_i32(_s, _rhs), do: err()
  def s_neq_i32(_s, _rhs), do: err()
  def s_gt_i32(_s, _rhs), do: err()
  def s_lt_i32(_s, _rhs), do: err()
  def s_gt_eq_i32(_s, _rhs), do: err()
  def s_lt_eq_i32(_s, _rhs), do: err()

  def s_eq_i64(_s, _rhs), do: err()
  def s_neq_i64(_s, _rhs), do: err()
  def s_gt_i64(_s, _rhs), do: err()
  def s_lt_i64(_s, _rhs), do: err()
  def s_gt_eq_i64(_s, _rhs), do: err()
  def s_lt_eq_i64(_s, _rhs), do: err()

  def s_eq_f32(_s, _rhs), do: err()
  def s_neq_f32(_s, _rhs), do: err()
  def s_gt_f32(_s, _rhs), do: err()
  def s_lt_f32(_s, _rhs), do: err()
  def s_gt_eq_f32(_s, _rhs), do: err()
  def s_lt_eq_f32(_s, _rhs), do: err()

  def s_eq_f64(_s, _rhs), do: err()
  def s_neq_f64(_s, _rhs), do: err()
  def s_gt_f64(_s, _rhs), do: err()
  def s_lt_f64(_s, _rhs), do: err()
  def s_gt_eq_f64(_s, _rhs), do: err()
  def s_lt_eq_f64(_s, _rhs), do: err()

  def s_eq_str(_s, _rhs), do: err()
  def s_neq_str(_s, _rhs), do: err()
  def s_gt_str(_s, _rhs), do: err()
  def s_lt_str(_s, _rhs), do: err()
  def s_gt_eq_str(_s, _rhs), do: err()
  def s_lt_eq_str(_s, _rhs), do: err()
  def s_to_json(_s), do: err()

  defp err, do: :erlang.nif_error(:nif_not_loaded)
end