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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_v Grouping.from_string("aeiouáéíóú")


  # Among tables
  @a_0 [
    {"imid", -1, 1, nil},
    {"aimid", 0, 1, nil},
    {"ímid", -1, 1, nil},
    {"aímid", 2, 1, nil},
    {"adh", -1, 2, nil},
    {"eadh", 4, 2, nil},
    {"faidh", -1, 1, nil},
    {"fidh", -1, 1, nil},
    {"áil", -1, 2, nil},
    {"ain", -1, 2, nil},
    {"tear", -1, 2, nil},
    {"tar", -1, 2, nil}
  ]
  @a_1 [
    {"óideacha", -1, 6, nil},
    {"patacha", -1, 5, nil},
    {"achta", -1, 1, nil},
    {"arcachta", 2, 2, nil},
    {"eachta", 2, 1, nil},
    {"grafaíochta", -1, 4, nil},
    {"paite", -1, 5, nil},
    {"ach", -1, 1, nil},
    {"each", 7, 1, nil},
    {"óideach", 8, 6, nil},
    {"gineach", 8, 3, nil},
    {"patach", 7, 5, nil},
    {"grafaíoch", -1, 4, nil},
    {"pataigh", -1, 5, nil},
    {"óidigh", -1, 6, nil},
    {"achtúil", -1, 1, nil},
    {"eachtúil", 15, 1, nil},
    {"gineas", -1, 3, nil},
    {"ginis", -1, 3, nil},
    {"acht", -1, 1, nil},
    {"arcacht", 19, 2, nil},
    {"eacht", 19, 1, nil},
    {"grafaíocht", -1, 4, nil},
    {"arcachtaí", -1, 2, nil},
    {"grafaíochtaí", -1, 4, nil}
  ]
  @a_2 [
    {"íochta", -1, 1, nil},
    {"aíochta", 0, 1, nil},
    {"ire", -1, 2, nil},
    {"aire", 2, 2, nil},
    {"abh", -1, 1, nil},
    {"eabh", 4, 1, nil},
    {"ibh", -1, 1, nil},
    {"aibh", 6, 1, nil},
    {"amh", -1, 1, nil},
    {"eamh", 8, 1, nil},
    {"imh", -1, 1, nil},
    {"aimh", 10, 1, nil},
    {"íocht", -1, 1, nil},
    {"aíocht", 12, 1, nil},
    {"irí", -1, 2, nil},
    {"airí", 14, 2, nil}
  ]
  @a_3 [
    {"b'", -1, 4, nil},
    {"bh", -1, 14, nil},
    {"bhf", 1, 9, nil},
    {"bp", -1, 11, nil},
    {"ch", -1, 15, nil},
    {"d'", -1, 2, nil},
    {"d'fh", 5, 3, nil},
    {"dh", -1, 16, nil},
    {"dt", -1, 13, nil},
    {"fh", -1, 17, nil},
    {"gc", -1, 7, nil},
    {"gh", -1, 18, nil},
    {"h-", -1, 1, nil},
    {"m'", -1, 4, nil},
    {"mb", -1, 6, nil},
    {"mh", -1, 19, nil},
    {"n-", -1, 1, nil},
    {"nd", -1, 8, nil},
    {"ng", -1, 10, nil},
    {"ph", -1, 20, nil},
    {"sh", -1, 5, nil},
    {"t-", -1, 1, nil},
    {"th", -1, 21, nil},
    {"ts", -1, 12, 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, p2: 0, pV: 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 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_verb_sfx(%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 result do
                    1 ->
                      case (fn state ->
                        r_RV(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_deriv(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_1) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      {:ok, Runtime.slice_from(state, "arc")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "gin")}
                    4 ->
                      {:ok, Runtime.slice_from(state, "graf")}
                    5 ->
                      {:ok, Runtime.slice_from(state, "paite")}
                    6 ->
                      {:ok, Runtime.slice_from(state, "óid")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_noun_sfx(%Runtime{} = state) do
    (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 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

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

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

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

  defp r_mark_regions(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:pV], state.limit)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, put_in(state.vars[:p1], state.limit)}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, put_in(state.vars[:p2], state.limit)}
        end).(state) do
          {:ok, state} ->
          {:ok, snowball_do_f(state, fn 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 ->
                {:ok, put_in(state.vars[:pV], state.cursor)}
              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} ->
                    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[:p2], state.cursor)}
                        r -> r
                      end
                      r -> r
                    end
                  end
                  r -> r
                end
              end
              r -> r
            end
          end)}
        end
      end
    end
  end

  defp r_initial_morph(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_3) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      {:ok, Runtime.slice_del(state)}
                    3 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    4 ->
                      {:ok, Runtime.slice_del(state)}
                    5 ->
                      {:ok, Runtime.slice_from(state, "s")}
                    6 ->
                      {:ok, Runtime.slice_from(state, "b")}
                    7 ->
                      {:ok, Runtime.slice_from(state, "c")}
                    8 ->
                      {:ok, Runtime.slice_from(state, "d")}
                    9 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    10 ->
                      {:ok, Runtime.slice_from(state, "g")}
                    11 ->
                      {:ok, Runtime.slice_from(state, "p")}
                    12 ->
                      {:ok, Runtime.slice_from(state, "s")}
                    13 ->
                      {:ok, Runtime.slice_from(state, "t")}
                    14 ->
                      {:ok, Runtime.slice_from(state, "b")}
                    15 ->
                      {:ok, Runtime.slice_from(state, "c")}
                    16 ->
                      {:ok, Runtime.slice_from(state, "d")}
                    17 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    18 ->
                      {:ok, Runtime.slice_from(state, "g")}
                    19 ->
                      {:ok, Runtime.slice_from(state, "m")}
                    20 ->
                      {:ok, Runtime.slice_from(state, "p")}
                    21 ->
                      {:ok, Runtime.slice_from(state, "t")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

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

end