#! /usr/bin/env elixir

defmodule Settings do
  def terminal do
    "urxvt"
  end
end

defmodule ArgParser do
  def parse do
    {opts, _} =
      System.argv()
      |> OptionParser.parse!(strict: [option: :string, text: :string])

    options = [
      camelize:          "text->camelize",
      dictionary:        "word->dictionary",
      first_letter:      "text->first-letter-words",
      kjv_lookup:        "verse->kjv",
      lorem_paragraph:   "lorem->paragraph",
      lorem_title:       "lorem->title",
      lower_case:        "case->lower",
      single_line:       "text->single-line",
      slugize:           "text->slugize",
      title_case:        "case->title",
      title_case_strict: "case->title-strict"
    ]

    cond do
      opts[:option] == options[:first_letter] ->
        TextPlumber.firstLetterOfWordsIn(opts[:text]) |> IO.binwrite()

      opts[:option] == options[:slugize] ->
        opts[:text]
        |> String.normalize(:nfd)
        |> String.replace(~r/[[:space:]]+/, " ")
        |> String.replace(~r/[[:punct:]]+/, " ")
        |> Macro.underscore()
        |> String.replace(~r/[[:space:]]+/, "-")
        |> String.replace(~r/[[:punct:]]+/, "-")
        |> String.trim("-")
        |> IO.binwrite()

      opts[:option] == options[:camelize] ->
        opts[:text]
        |> String.normalize(:nfd)
        |> String.replace(~r/[[:space:]]+/, "_")
        |> String.replace(~r/[[:punct:]]+/, "_")
        |> Macro.camelize()
        |> String.replace(~r/[[:space:]]+/, "")
        |> String.replace(~r/[[:punct:]]+/, "")
        |> IO.binwrite()

      opts[:option] == options[:single_line] ->
        TextPlumber.singleLineOf(opts[:text]) |> IO.binwrite()

      opts[:option] == options[:dictionary] ->
        TextPlumber.dictionOfFirstWordIn(opts[:text])
        TextPlumber.firstWordOf(opts[:text]) |> IO.binwrite()

      opts[:option] == options[:title_case] ->
        opts[:text] |> to_string |> TextPlumber.titleCaseOf() |> IO.binwrite()

      opts[:option] == options[:title_case_strict] ->
        String.downcase(opts[:text]) |> TextPlumber.titleCaseOf() |> IO.binwrite()

      opts[:option] == options[:lower_case] ->
        String.downcase(opts[:text]) |> IO.binwrite()

      opts[:option] == options[:lorem_title] ->
        TextPlumber.loremTitle()

      opts[:option] == options[:lorem_paragraph] ->
        TextPlumber.loremParagraph()

      opts[:option] == options[:kjv_lookup] ->
        System.cmd(Settings.terminal(), [
          "-e",
          "sh",
          "-c",
          "kjv #{TextPlumber.singleLineOf(opts[:text])}"
        ])

        TextPlumber.singleLineOf(opts[:text]) |> IO.binwrite()

      true ->
        Enum.each(options, fn {_, value} -> IO.puts(value) end)
    end
  end
end

defmodule TextPlumber do
  def firstLetterOfWordsIn(text) do
    String.replace(text, ~r/(\w)\w*/, "\\1", global: true)
    |> String.replace(~r/\s\s+/, " ", global: true)
  end

  def singleLineOf(text) do
    String.replace(text, "\n", " ")
    |> String.replace(~r/\s\s+/, " ", global: true)
  end

  def firstWordOf(text) do
    String.split(text) |> List.first()
  end

  def titleCaseOf(text) do
    text |> String.split() |> Enum.map(fn word -> :string.titlecase(word) end) |> Enum.join(" ")
  end

  def loremParagraph() do
    {string, _return} =
      System.cmd("sh", [
        "-c",
        "perl -e 'use Text::Lorem; use Text::Wrap; $Text::Wrap::columns = 80; print wrap(\"\", \"\", Text::Lorem->new()->sentences(5));'"
      ])

    IO.puts(string)
  end

  def loremTitle() do
    {string, _return} =
      System.cmd("sh", [
        "-c",
        "perl -e 'use Text::Lorem; print Text::Lorem->new()->words(4)';"
      ])

    IO.puts(string)
  end

  def dictionOfFirstWordIn(text) do
    System.cmd(Settings.terminal(), [
      "-e",
      "sh",
      "-c",
      "dict -h localhost #{TextPlumber.firstWordOf(text)} 2>&1 | vim -"
    ])
  end
end

ArgParser.parse()