# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Polish do
  @moduledoc """
  Snowball stemmer for polish.

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_v Grouping.from_string("aąeęioóuy")


  # Among tables
  @a_0 [
    {"ń", -1, 2, nil},
    {"ć", -1, 1, nil},
    {"ś", -1, 3, nil},
    {"ź", -1, 4, nil}
  ]
  @a_1 [
    {"byście", -1, 1, nil},
    {"bym", -1, 1, nil},
    {"by", -1, 1, nil},
    {"byśmy", -1, 1, nil},
    {"byś", -1, 1, nil}
  ]
  @a_2 [
    {"ąc", -1, 1, nil},
    {"ając", 0, 1, nil},
    {"sząc", 0, 2, nil},
    {"sz", -1, 1, nil},
    {"iejsz", 3, 1, nil}
  ]
  defp a_3 do
    [
      {"a", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ąca", 0, 6, nil},
      {"ająca", 1, 6, nil},
      {"sząca", 1, 7, nil},
      {"ia", 0, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"sza", 0, 6, nil},
      {"iejsza", 5, 6, nil},
      {"ała", 0, 1, nil},
      {"iała", 7, 1, nil},
      {"iła", 0, 1, nil},
      {"ąc", -1, 1, nil},
      {"ając", 10, 1, nil},
      {"e", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ące", 12, 6, nil},
      {"ające", 13, 6, nil},
      {"szące", 13, 7, nil},
      {"ie", 12, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"cie", 16, 1, nil},
      {"acie", 17, 1, nil},
      {"ecie", 17, 1, nil},
      {"icie", 17, 1, nil},
      {"ajcie", 17, 1, nil},
      {"liście", 17, 4, nil},
      {"aliście", 22, 1, nil},
      {"ieliście", 22, 1, nil},
      {"iliście", 22, 1, nil},
      {"łyście", 17, 4, nil},
      {"ałyście", 26, 1, nil},
      {"iałyście", 27, 1, nil},
      {"iłyście", 26, 1, nil},
      {"sze", 12, 6, nil},
      {"iejsze", 30, 6, nil},
      {"ach", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iach", 32, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ich", -1, 5, nil},
      {"ych", -1, 5, nil},
      {"i", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ali", 36, 1, nil},
      {"ieli", 36, 1, nil},
      {"ili", 36, 1, nil},
      {"ami", 36, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iami", 40, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"imi", 36, 5, nil},
      {"ymi", 36, 5, nil},
      {"owi", 36, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iowi", 44, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"aj", -1, 1, nil},
      {"ej", -1, 5, nil},
      {"iej", 47, 5, nil},
      {"am", -1, 1, nil},
      {"ałam", 49, 1, nil},
      {"iałam", 50, 1, nil},
      {"iłam", 49, 1, nil},
      {"em", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iem", 53, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ałem", 53, 1, nil},
      {"iałem", 55, 1, nil},
      {"iłem", 53, 1, nil},
      {"im", -1, 5, nil},
      {"om", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iom", 59, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ym", -1, 5, nil},
      {"o", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ego", 62, 5, nil},
      {"iego", 63, 5, nil},
      {"ało", 62, 1, nil},
      {"iało", 65, 1, nil},
      {"iło", 62, 1, nil},
      {"u", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"iu", 68, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"emu", 68, 5, nil},
      {"iemu", 70, 5, nil},
      {"ów", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"y", -1, 5, nil},
      {"amy", 73, 1, nil},
      {"emy", 73, 1, nil},
      {"imy", 73, 1, nil},
      {"liśmy", 73, 4, nil},
      {"aliśmy", 77, 1, nil},
      {"ieliśmy", 77, 1, nil},
      {"iliśmy", 77, 1, nil},
      {"łyśmy", 73, 4, nil},
      {"ałyśmy", 81, 1, nil},
      {"iałyśmy", 82, 1, nil},
      {"iłyśmy", 81, 1, nil},
      {"ały", 73, 1, nil},
      {"iały", 85, 1, nil},
      {"iły", 73, 1, nil},
      {"asz", -1, 1, nil},
      {"esz", -1, 1, nil},
      {"isz", -1, 1, nil},
      {"ał", -1, 1, nil},
      {"iał", 91, 1, nil},
      {"ił", -1, 1, nil},
      {"ą", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ącą", 94, 6, nil},
      {"ającą", 95, 6, nil},
      {"szącą", 95, 7, nil},
      {"ią", 94, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
      {"ają", 94, 1, nil},
      {"szą", 94, 3, nil},
      {"iejszą", 100, 6, nil},
      {"ać", -1, 1, nil},
      {"ieć", -1, 1, nil},
      {"ić", -1, 1, nil},
      {"ąć", -1, 1, nil},
      {"aść", -1, 1, nil},
      {"eść", -1, 1, nil},
      {"ę", -1, 1, nil},
      {"szę", 108, 2, nil},
      {"łaś", -1, 4, nil},
      {"ałaś", 110, 1, nil},
      {"iałaś", 111, 1, nil},
      {"iłaś", 110, 1, nil},
      {"łeś", -1, 4, nil},
      {"ałeś", 114, 1, nil},
      {"iałeś", 115, 1, nil},
      {"iłeś", 114, 1, nil}
    ]
  end

  @doc """
  Stem a word.

  ### Arguments

  * `word` is a UTF-8 binary.

  ### Returns

  * The stemmed UTF-8 binary.

  """
  @spec stem(binary()) :: binary()
  def stem(word) when is_binary(word) do
    state = Runtime.new(word) |> init_vars()
    state = run_stem(state)
    Runtime.assign_to(state)
  end

  defp init_vars(state), do: %{state | vars: %{p1: 0}}

  defp run_stem(%Runtime{} = state) do
    {_, state} = r_stem(state)
    state
  end

  # Snowball runtime helpers.
  defp snowball_do_f(state, fun) do
    saved_c = state.cursor
    {_, s} = fun.(state)
    %{s | cursor: saved_c}
  end

  defp snowball_do_b(state, fun) do
    rel = state.limit - state.cursor
    {_, s} = fun.(state)
    %{s | cursor: s.limit - rel}
  end

  defp snowball_test_b(state, fun) do
    rel = state.limit - state.cursor
    case fun.(state) do
      {:ok, s} -> {:ok, %{s | cursor: s.limit - rel}}
      {:fail, s} -> {:fail, %{s | cursor: s.limit - rel}}
    end
  end

  defp snowball_try(state, fun) do
    rel = state.limit - state.cursor
    case fun.(state) do
      {:ok, s} -> s
      {:fail, s} -> %{s | cursor: s.limit - rel}
    end
  end

  defp snowball_or(state, fun1, fun2) do
    rel = state.limit - state.cursor
    case fun1.(state) do
      {:ok, s} -> {:ok, s}
      {:fail, s} -> fun2.(%{s | cursor: s.limit - rel})
    end
  end

  defp lift(state, :fail), do: {:fail, state}
  defp lift(_state, %Runtime{} = s), do: {:ok, s}

  defp next_codepoint(%Runtime{cursor: c, limit: lim, current: cur} = state) do
    case Runtime.codepoint_at(cur, c, lim) do
      {_cp, size} -> {:ok, %{state | cursor: c + size}}
      :error -> {:fail, state}
    end
  end

  defp r_normalize_consonant(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_0) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case (fn state ->
            (fn state ->
              saved_c = state.cursor
              case (fn state ->
              if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
              end).(state) do
                {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                {:fail, s} -> {:ok, %{s | cursor: saved_c}}
              end
            end).(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "c")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "n")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "s")}
                    4 ->
                      {:ok, Runtime.slice_from(state, "z")}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_remove_endings(%Runtime{} = state) do
    case (fn state ->
      {:ok, snowball_do_b(state, fn state ->
        (fn ->
          old_limit = state.limit_backward
          case (fn state ->
            (fn ->
              target = state.vars[:p1]
              if target < state.limit_backward or target > state.limit do
                {:fail, state}
              else
                {:ok, %{state | cursor: target}}
              end
            end).()
          end).(state) do
            {:fail, _} -> {:fail, state}
            {:ok, limit_state} ->
              state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
              case Runtime.find_among_b(state, @a_1) do
                :fail -> {:fail, %{state | limit_backward: old_limit}}
                {%Runtime{} = s, result} ->
                  state = %{s | bra: s.cursor, limit_backward: old_limit}
              case result do
                        1 ->
                          {:ok, Runtime.slice_del(state)}
                _ -> {:ok, state}
              end
              end
          end
        end).()
      end)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        (fn ->
          state = %{state | ket: state.cursor}
          case Runtime.find_among_b(state, a_3()) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | bra: s.cursor}
              case result do
                        1 ->
                          {:ok, Runtime.slice_del(state)}
                        2 ->
                          {:ok, Runtime.slice_from(state, "s")}
                        3 ->
                          snowball_or(state,
                            fn state ->
                              case (fn state ->
                                snowball_test_b(state, fn state ->
                                  r_R1(state)
                                end)
                              end).(state) do
                                {:ok, state} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                            end,
                            fn state ->
                              {:ok, Runtime.slice_from(state, "s")}
                            end)
                        4 ->
                          {:ok, Runtime.slice_from(state, "ł")}
                        5 ->
                          case (fn state ->
                            {:ok, Runtime.slice_del(state)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, snowball_try(state, fn state ->
                              (fn ->
                                state = %{state | ket: state.cursor}
                                case Runtime.find_among_b(state, @a_2) do
                                  :fail -> {:fail, state}
                                  {%Runtime{} = s, result} ->
                                    state = %{s | bra: s.cursor}
                                    case result do
                                              1 ->
                                                {:ok, Runtime.slice_del(state)}
                                              2 ->
                                                {:ok, Runtime.slice_from(state, "s")}
                                      _ -> {:ok, state}
                                    end
                                end
                              end).()
                            end)}
                          end
                        6 ->
                          {:ok, Runtime.slice_del(state)}
                        7 ->
                          {:ok, Runtime.slice_from(state, "s")}
                        8 ->
                          {:ok, Runtime.slice_del(state)}
                _ -> {:ok, state}
              end
          end
        end).()
      end).(state) do
        {:ok, state} ->
        {:ok, snowball_try(state, fn state ->
          case (fn state ->
            {:ok, %{state | ket: state.cursor}}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              lift(state, Runtime.eq_s_b(state, "'"))
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                {:ok, %{state | bra: state.cursor}}
              end).(state) do
                {:ok, state} ->
                {:ok, Runtime.slice_del(state)}
              end
              r -> r
            end
          end
        end)}
        r -> r
      end
    end
  end

  defp r_R1(%Runtime{} = state) do
    if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
  end

  defp r_mark_regions(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:p1], state.limit)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        case Runtime.go_out_grouping(state, @g_v) do
          :fail -> {:fail, state}
          %Runtime{} = s -> next_codepoint(s)
        end
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          case Runtime.go_in_grouping(state, @g_v) do
            :fail -> {:fail, state}
            %Runtime{} = s -> next_codepoint(s)
          end
        end).(state) do
          {:ok, state} ->
          {:ok, put_in(state.vars[:p1], state.cursor)}
          r -> r
        end
        r -> r
      end
    end
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      {:ok, snowball_do_f(state, fn state ->
        r_mark_regions(state)
      end)}
    end).(state) do
      {:ok, state} ->
      snowball_or(state,
        fn state ->
          case (fn state ->
            (fn ->
              n = 2
              Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                case next_codepoint(s) do
                  {:ok, s2} -> {:cont, {:ok, s2}}
                  {:fail, _} -> {:halt, {:fail, state}}
                end
              end)
            end).()
          end).(state) do
            {:ok, state} ->
            (fn state ->
              old_cursor = state.cursor
              old_lb = state.limit_backward
              state = %{state | cursor: state.limit, limit_backward: old_cursor}
              {tag, s} = (fn state ->
                r_remove_endings(state)
              end).(state)
              {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
            end).(state)
            r -> r
          end
        end,
        fn state ->
          (fn state ->
            old_cursor = state.cursor
            old_lb = state.limit_backward
            state = %{state | cursor: state.limit, limit_backward: old_cursor}
            {tag, s} = (fn state ->
              r_normalize_consonant(state)
            end).(state)
            {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
          end).(state)
        end)
    end
  end

end