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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_env_ending Grouping.from_string("bcčdhkprsštvzž")
  @g_ev_ending Grouping.from_string("hknrtz")
  @g_v Grouping.from_string("aeiouyáěéíóúůý")
  @g_v_or_syllabic_c Grouping.from_string("aeiouyáěéíóúůýlr")


  # Among tables
  @a_0 [
    {"", -1, 2, nil},
    {"l", 0, 1, nil},
    {"tl", 1, 2, nil},
    {"s", 0, 1, nil},
    {"es", 3, 2, nil},
    {"č", 0, 1, nil},
    {"eč", 5, 2, nil},
    {"ř", 0, 1, nil},
    {"ž", 0, 1, nil}
  ]
  @a_1 [
    {"obl", -1, -1, nil},
    {"sn", -1, -1, nil},
    {"dot", -1, -1, nil}
  ]
  @a_2 [
    {"uc", -1, -1, nil},
    {"h", -1, -1, nil},
    {"ok", -1, -1, nil},
    {"kar", -1, -1, nil},
    {"č", -1, -1, nil}
  ]
  @a_3 [
    {"a", -1, 1, nil},
    {"ama", 0, 1, nil},
    {"ata", 0, 1, nil},
    {"eb", -1, 5, nil},
    {"ec", -1, 6, nil},
    {"e", -1, 3, nil},
    {"ete", 5, 4, nil},
    {"ěte", 5, 2, nil},
    {"ech", -1, 3, nil},
    {"atech", 8, 1, nil},
    {"ách", -1, 1, nil},
    {"ích", -1, 13, nil},
    {"ých", -1, 1, nil},
    {"i", -1, 13, nil},
    {"mi", 13, 1, nil},
    {"ami", 14, 1, nil},
    {"emi", 14, 3, nil},
    {"ěmi", 14, 2, nil},
    {"ťmi", 14, 12, nil},
    {"ími", 14, 13, nil},
    {"ými", 14, 1, nil},
    {"eti", 13, 4, nil},
    {"ěti", 13, 2, nil},
    {"ovi", 13, 1, nil},
    {"ek", -1, 7, nil},
    {"ěk", -1, 8, nil},
    {"em", -1, 3, nil},
    {"etem", 26, 4, nil},
    {"ětem", 26, 2, nil},
    {"ěm", -1, 2, nil},
    {"ám", -1, 1, nil},
    {"ém", -1, 1, nil},
    {"ím", -1, 13, nil},
    {"ům", -1, 1, nil},
    {"atům", 33, 1, nil},
    {"ým", -1, 1, nil},
    {"o", -1, 1, nil},
    {"ého", 36, 1, nil},
    {"ího", 36, 13, nil},
    {"us", -1, 1, nil},
    {"at", -1, 1, nil},
    {"et", -1, 10, nil},
    {"u", -1, 1, nil},
    {"ému", 42, 1, nil},
    {"ímu", 42, 13, nil},
    {"ou", 42, 1, nil},
    {"ev", -1, 11, nil},
    {"y", -1, 1, nil},
    {"aty", 47, 1, nil},
    {"eň", -1, 9, nil},
    {"ě", -1, 2, nil},
    {"á", -1, 1, nil},
    {"ť", -1, 12, nil},
    {"é", -1, 1, nil},
    {"ové", 53, 1, nil},
    {"í", -1, 13, nil},
    {"ů", -1, 1, nil},
    {"ý", -1, 1, nil}
  ]
  @a_4 [
    {"in", -1, 2, nil},
    {"ov", -1, 1, nil},
    {"ův", -1, 1, nil}
  ]
  @a_5 [
    {"c", -1, 1, nil},
    {"nc", 0, -1, nil},
    {"ínc", 1, 2, nil},
    {"avc", 0, -1, nil},
    {"ovc", 0, -1, nil},
    {"čt", -1, 3, nil},
    {"št", -1, 4, nil},
    {"dešt", 6, -1, nil},
    {"lešt", 6, -1, nil},
    {"išt", 6, -1, nil},
    {"poušt", 6, -1, nil},
    {"ášt", 6, -1, nil},
    {"íšt", 6, -1, nil}
  ]
  @a_6 [
    {"c", -1, 1, nil},
    {"nc", 0, -1, nil},
    {"ínc", 1, 2, nil},
    {"avc", 0, -1, nil},
    {"ovc", 0, -1, nil}
  ]

  @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, x: 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_f(state, fun) do
    saved_c = state.cursor
    case fun.(state) do
      {:ok, s} -> {:ok, %{s | cursor: saved_c}}
      {:fail, s} -> {:fail, %{s | cursor: saved_c}}
    end
  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_case_suffix(%Runtime{} = state) do
    (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_3) 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)}
                    2 ->
                      {:ok, Runtime.slice_del(state)}
                    3 ->
                      case (fn state ->
                        {:ok, Runtime.slice_del(state)}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, snowball_try(state, fn state ->
                          r_palatalise_e(state)
                        end)}
                      end
                    4 ->
                      (fn ->
                        case Runtime.find_among_b(state, @a_0) do
                          :fail -> {:fail, state}
                          {%Runtime{} = s, result} ->
                            state = s
                            case result do
                              1 ->
                                {:ok, Runtime.slice_del(state)}
                              2 ->
                                {:ok, Runtime.slice_from(state, "et")}
                              _ -> {:ok, s}
                            end
                        end
                      end).()
                    5 ->
                      case (fn state ->
                        snowball_test_b(state, fn state ->
                          lift(state, Runtime.out_grouping_b(state, @g_v))
                        end)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          (fn state ->
                            saved_c = state.cursor
                            case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "tř"))
                            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} ->
                          {:ok, Runtime.slice_from(state, "b")}
                          r -> r
                        end
                        r -> r
                      end
                    6 ->
                      case (fn state ->
                        snowball_test_b(state, fn state ->
                          lift(state, Runtime.out_grouping_b(state, @g_v))
                        end)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            (fn ->
                              saved_c = state.cursor
                              new_state = Runtime.insert(state, saved_c, saved_c, "c")
                              {:ok, %{new_state | cursor: saved_c + byte_size("c")}}
                            end).()
                          end).(state) do
                            {:ok, state} ->
                            {:ok, snowball_try(state, fn state ->
                              r_palatalise_e(state)
                            end)}
                          end
                        end
                        r -> r
                      end
                    7 ->
                      case (fn state ->
                        snowball_test_b(state, fn state ->
                          lift(state, Runtime.out_grouping_b(state, @g_v))
                        end)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          (fn state ->
                            saved_c = state.cursor
                            case (fn state ->
                            (fn ->
                              case Runtime.find_among_b(state, @a_1) do
                                :fail -> {:fail, state}
                                {%Runtime{} = s, _} -> {:ok, s}
                              end
                            end).()
                            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} ->
                          {:ok, Runtime.slice_from(state, "k")}
                          r -> r
                        end
                        r -> r
                      end
                    8 ->
                      case (fn state ->
                        lift(state, Runtime.eq_s_b(state, "n"))
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, %{state | bra: state.cursor}}
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "ňk")}
                        end
                        r -> r
                      end
                    9 ->
                      case (fn state ->
                        snowball_test_b(state, fn state ->
                          lift(state, Runtime.in_grouping_b(state, @g_env_ending))
                        end)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "n")}
                        r -> r
                      end
                    10 ->
                      case (fn state ->
                        (fn ->
                          case Runtime.find_among_b(state, @a_2) do
                            :fail -> {:fail, state}
                            {%Runtime{} = s, _} -> {:ok, s}
                          end
                        end).()
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "t")}
                        r -> r
                      end
                    11 ->
                      case (fn state ->
                        lift(state, Runtime.in_grouping_b(state, @g_ev_ending))
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "v")}
                        r -> r
                      end
                    12 ->
                      {:ok, Runtime.slice_from(state, "t")}
                    13 ->
                      case (fn state ->
                        {:ok, Runtime.slice_del(state)}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, snowball_try(state, fn state ->
                          r_palatalise_i(state)
                        end)}
                      end
            _ -> {:ok, state}
          end
          end
      end
    end).()
  end

  defp r_possessive_suffix(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_4) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      case (fn state ->
                        {:ok, Runtime.slice_del(state)}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, snowball_try(state, fn state ->
                          r_palatalise_i(state)
                        end)}
                      end
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_palatalise_i(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_5) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "k")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "ínk")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "ck")}
                    4 ->
                      {:ok, Runtime.slice_from(state, "sk")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_palatalise_e(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_6) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "k")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "ínk")}
            _ -> {:ok, state}
          end
      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 ->
      snowball_test_f(state, fn state ->
        case (fn state ->
          (fn ->
            n = 3
            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} ->
          {:ok, put_in(state.vars[:x], state.cursor)}
          r -> r
        end
      end)
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, put_in(state.vars[:p1], state.limit)}
      end).(state) do
        {:ok, state} ->
        {:ok, snowball_do_f(state, fn state ->
          case (fn state ->
            snowball_or(state,
              fn state ->
                lift(state, Runtime.in_grouping(state, @g_v))
              end,
              fn state ->
                case (fn state ->
                  next_codepoint(state)
                end).(state) do
                  {:ok, state} ->
                  case Runtime.go_out_grouping(state, @g_v_or_syllabic_c) do
                    :fail -> {:fail, state}
                    %Runtime{} = s -> next_codepoint(s)
                  end
                  r -> r
                end
              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} ->
              case (fn state ->
                {:ok, put_in(state.vars[:p1], state.cursor)}
              end).(state) do
                {:ok, state} ->
                {:ok, snowball_try(state, fn state ->
                  case (fn state ->
                    if state.vars[:p1] < state.vars[:x], do: {:ok, state}, else: {:fail, state}
                  end).(state) do
                    {:ok, state} ->
                    {:ok, put_in(state.vars[:p1], state.vars[:x])}
                    r -> r
                  end
                end)}
              end
              r -> r
            end
            r -> r
          end
        end)}
      end
      r -> r
    end
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      r_mark_regions(state)
    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 ->
          case (fn state ->
            {:ok, snowball_do_b(state, fn state ->
              r_case_suffix(state)
            end)}
          end).(state) do
            {:ok, state} ->
            {:ok, snowball_do_b(state, fn state ->
              r_possessive_suffix(state)
            end)}
          end
        end).(state)
        {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
      end).(state)
      r -> r
    end
  end

end