path: root/lib/irc/connection.ex

defmodule Irc.Connection do
  @behaviour :gen_statem
  require Logger
  alias Irc.Parser.Line
  require Irc.Parser.Numeric
  import Irc.Parser.Numeric

  @backoff_min :timer.seconds(5)
  @backoff_max :timer.minutes(15)
  @connect_timeout :timer.minutes(1)
  @reply_timeout :timer.seconds(1)
  @cap_timeout :timer.seconds(15)
  @registration_timeout :timer.seconds(30)
  @support_capabs ["sasl", "cap-notify"]
  @internal {:next_event, :internal, nil}

  defstruct [:server, :nick, :modes, :capabs, :server_version, :server_umodes, :server_cmodes, :server_cmodes_with_params, :isupport, :motd]

  @typedoc "Connection Information state"
  @type t :: %__MODULE__{
    server: String.t,
    nick: String.t,
    capabs: list(),
    modes: String.t,
    server_version: String.t,
    server_umodes: String.t,
    server_cmodes: String.t,
    server_cmodes_with_params: String.t,
    isupport: isupport(),
    motd: [String.t],
  }

  @typedoc "Server ISUPPORT"
  @type isupport :: %{String.t() => true | nil | String.t | %{String.t() => any()}}

  @typedoc "Messages sent to the owning process."
  @type message :: msg_up() | msg_down() | msg_error()
                  | msg_line() | msg_umodes() | msg_nick()

  @typedoc "Connection is now up and registered."
  @type msg_up :: {:irc_conn_up, pid(), t()}
  @typedoc "Message: Received an IRC line."
  @type msg_line :: {:irc_conn_line, pid(), Line.t}
  @typedoc "Message: Connection user modes have changed."
  @type msg_umodes :: {:irc_conn_modes, pid(), changes :: String.t, previous_modes :: list(), modes :: list()}
  @typedoc "Message: Connection nickname have changed."
  @type msg_nick :: {:irc_conn_nick, pid(), previous_nick :: String.t, new_nick :: String.t}
  @typedoc "Message: Connection is down and will try to reconnect in `delay`."
  @type msg_down :: {:irc_conn_down, pid(), error, delay :: integer}
  @typedoc "Message: Connection encountered a fatal error and stopped."
  @type msg_error :: {:irc_conn_error, pid(), error}

  @typedoc "Connection error reasons"
  @type error :: {:error, error_irc | any}

  @typedoc "IRC Error reasons"
  @type error_irc :: {:killed, by :: String.t, reason :: String.t}
                      | {:quit, reason :: String.t}
                      | {:irc_error, reason :: String.t}

  @typedoc """
  Start options.

  * user: IRC user,
  * name: IRC real name,
  * pass: IRC server password,
  * capabs: IRCv3 capabs to request (if available),
  * port,
  * tls,
  * reconnect,
  * process,
  * tcp_opts and tls_opts.
  """
  @type start_opt :: {:user, nil | String.t}
                  | {:name, nil | String.t}
                  | {:pass, nil | String.t}
                  | {:capabs, [String.t]}
                  | {:port, 6667 | Integer.t}
                  | {:tls, false | true}
                  | {:inet, nil | 4 | 6}
                  | {:iface, nil | String.t}
                  | {:ip, nil | String.t}
                  | {:reconnect, true | false}
                  | {:process, pid}
                  | {:tcp_opts, [:gen_tcp.connect_option]}
                  | {:tls_opts, [:ssl.connect_option]}

  @moduledoc """
  Lightweight implementation of an IRC Connection handling only the basics:

    * the socket and reconnections,
    * registration process,
    * sasl authentication,
    * capabilities negotiation,
    * ping,
    * nick and user mode changes.

  Events and lines are sent to calling PID.

  ## Usage

  The client is started using `start/4` or `start_link/4`:

  ```elixir
  {:ok, Pid} = Irc.Connection.start("ExIrcTest", "irc.random.sh", [tls: true, port: 6697], [])
  ```

  Messages will be sent to your PID, see `t:message/0` for the possible types.

  You can send lines using `sendline/3`, and disconnect with `disconnect/3`.

  Status and information about the connection (`t:t/0`) can be requested with `info/1`.

  If you are looking for a more featured client, you probably want `Irc.Client`!
  """

  @type nick :: String.t
  @type host :: String.t

  @type start_ret :: {:ok, pid} | {:error, error} | :gen_statem.start_ret

  @spec start(nick, host, [start_opt], [:gen_statem.start_opt]) :: start_ret
  @doc """
  Start a connection.
  """
  def start(nick, host, opts \\ [], start_opts \\ []) do
    :gen_statem.start(__MODULE__, [prepare_args(nick, host, opts)], start_opts)
  end

  @spec start_link(nick, host, [start_opt], [:gen_statem.start_opt]) :: start_ret
  @doc """
  Start and link a connection.
  """
  def start_link(nick, host, opts \\ [], start_opts \\ []) do
    :gen_statem.start_link(__MODULE__, [prepare_args(nick, host, opts)], start_opts)
  end


  @spec reconnect(pid) :: :ok | {:error, :not_disconnected}
  @doc """
  Reconnects the connection.

  Can only be used when the connection is disconnected. This will override either a `disconnect/3`, or re-connect early after an error
  """
  def reconnect(pid) do
    :gen_statem.call(pid, :reconnect)
  end

  @spec disconnect(pid, quit_message :: String.t, stop :: boolean) :: :ok | {:error, :not_connected} | {:error, :noproc}
  @doc """
  Disconnects.

  If `stop` is set to false (default true), the connection PID will keep running and can be reconnected with `reconnect/1`
  """
  def disconnect(pid, quit_message \\ nil, stop \\ true) do
    :gen_statem.call(pid, {:disconnect, stop, quit_message})
  catch
    :exit, {:noproc, _} -> {:error, :noproc}
  end

  @spec info(pid) :: {:connected, t()} | :connecting | :disconnected
  @doc "Returns the connection state and info."
  def info(pid) do
    :gen_statem.call(pid, :info)
  end

  @spec sendline(pid, iolist, sync :: boolean) :: :ok | {:error, :not_connected} | msg_error
  @doc "Sends a line over the connection."
  def sendline(pid, data, sync \\ true) do
    fun = if sync, do: :call, else: :cast
    apply(:gen_statem, fun, [pid, {:send, data}])
  end

  @doc "Wait until the connection is registered."
  @spec await_up(pid, non_neg_integer | :infinity) :: {:ok, t} | msg_error | {:error, :await_up_timeout}
  def await_up(pid, timeout \\ :infinity) do
    mon = Process.monitor(pid)
    result = receive do
      {:irc_conn_up, pid, info} -> {:ok, info}
      {:irc_conn_error, pid, error} -> {:error, error}
      {:DOWN, _, :process, pid, _} -> {:error, :down}
    after
      timeout -> {:error, :await_up_timeout}
    end
    flush(pid)
    Process.demonitor(mon)
    result
  end

  @doc "Flush all messages from the connection."
  def flush(pid) do
    receive do
      {:irc_conn_up, pid, _} -> flush(pid)
      {:irc_conn_line, pid, _} -> flush(pid)
      {:irc_conn_modes, pid, _, _, _} -> flush(pid)
      {:irc_conn_nick, pid, _, _} -> flush(pid)
      {:irc_conn_down, pid, _, _} -> flush(pid)
      {:irc_conn_error, pid, _} -> flush(pid)
    after
      0 -> :ok
    end
  end

  defmodule State do
    @moduledoc false
    defstruct [:args,
      :backoff, :socket, :sockmodule, {:tries, 0},
      :process, :monitor,
      :nick,
      :server,
      :server_version,
      :server_umodes,
      :server_cmodes,
      :server_cmodes_with_params,
      :welcomed,
      {:errored, false},
      {:isupport, %{}},
      {:modes, []},
      {:server_capabs, []},
      {:req_capabs, []},
      {:capabs, []},
      {:buffer, []},
      {:motd, []},
      {:welcome, []},
    ]
  end

  @doc false
  def callback_mode, do: [:state_functions, :state_enter]

  @doc false
  def init([args]) do
    backoff_min = Keyword.get(args, :backoff_min, @backoff_min)
    backoff_max = Keyword.get(args, :backoff_max, @backoff_max)
    process = Keyword.get(args, :process, nil)
    monitor = Process.monitor(process)
    with \
         {:ok, processed_args} <- process_args(args),
         backoff <- :backoff.init(backoff_min, backoff_max)
    do
      data = %State{
        args: processed_args,
        process: process,
        monitor: monitor,
        backoff: backoff
      }
      {:ok, :connect, data, @internal}
    else
      {:error, error} ->
        {:stop, error}
    end
  end

  # TCP Open

  @doc false
  def connect(:internal, _, data = %{args: %{tls: true}}) do
    {:next_state, :connect_tls, data, {:next_event, :internal, nil}}
  end

  def connect(:internal, _, data) do
    Logger.debug("#{inspect(data)} connecting...")
    options = data.args.bind ++ data.args.inet ++ [{:active, true}, {:packet, :line}] ++ data.args.tcp_opts
    case :gen_tcp.connect(String.to_charlist(data.args.host), data.args.port, options) do
      {:ok, socket} ->
        {_, backoff} = :backoff.succeed(data.backoff)
        {:next_state, :connected, %State{data | backoff: backoff}, {:next_event, :internal, {:gen_tcp, socket}}}
      error ->
        # TODO ERRORS
        to_disconnected(error, data)
    end
  end

  def connect(type, content, data) do
    handle_common(:connect, type, content, data)
  end

  # TLS Connect

  @doc false
  def connect_tls(:internal, nil, data) do
    options = data.args.bind ++ data.args.inet ++ [{:active, true}, {:packet, :line}] ++ data.args.tcp_opts ++ data.args.tls_opts
    case :ssl.connect(String.to_charlist(data.args.host), data.args.port, options) do
      {:ok, socket} ->
        {_, backoff} = :backoff.succeed(data.backoff)
        {:next_state, :connected, %State{data | backoff: backoff}, {:next_event, :internal, {:ssl, socket}}}
      error ->
        to_disconnected(error, data)
    end
  end

  def connect_tls(type, content, data) do
    handle_common(:connect_tls, type, content, data)
  end

  @doc false
  def connected(:internal, {module, socket}, data) do
    {:next_state, :cap_ls, %State{data | sockmodule: module, socket: socket}, @internal}
  end

  def connected(type, content, data) do
    handle_common(:connected, type, content, data)
  end

  # Registration: LIST CAPABS

  @doc false
  def cap_ls(:internal, _, data) do
    case socksend(data, 'CAP LS 320') do
      :ok -> {:keep_state_and_data, {:state_timeout, @cap_timeout, nil}}
      error ->
        Logger.error("Disconnected in socksend")
        to_disconnected(error, data)
    end
  end

  def cap_ls(:info, msg = {module, socket, line}, data) do
    case Line.parse(line) do
      l = %Line{command: "CAP", args: [_, "LS", "*", rest]} ->
        capabs = String.split(rest, " ")
        {:keep_state, %State{data | server_capabs: data.capabs ++ capabs}, {:state_timeout, @reply_timeout, nil}}
      l = %Line{command: "CAP", args: ["*", "LS", rest]} ->
        capabs = Enum.uniq(data.capabs ++ String.split(rest, " "))
        {:next_state, :reg_pass, %State{data | server_capabs: capabs}, @internal}
      # TODO: What do?
      l ->
        handle_common(:cap_ls, :info, msg, data)
      #    {:next_state, :registration, data, {:next_event, :internal, nil}}
    end
  end

  def cap_ls(:state_timeout, _, data) do
    capabs = Enum.uniq(data.capabs)
    Logger.debug("State timeout")
    {:next_state, :reg_pass, %State{data | server_capabs: capabs}, @internal}
  end

  def cap_ls(type, content, data) do
    Logger.debug("Handling common #{inspect({type,content,data})}")
    handle_common(:cap_ls, type, content, data)
  end

  # Registration: PASS

  @doc false
  def reg_pass(:internal, _, data = %State{args: %{pass: pass}}) when is_binary(pass) and pass != "" do
    case socksend(data, ['PASS ', pass]) do
      :ok ->
        {:keep_state_and_data, {:state_timeout, @reply_timeout, nil}}
      error ->
        to_disconnected(error, data)
    end
  end

  def reg_pass(:internal, _, data) do
    {:next_state, :reg_nick, data, @internal}
  end

  def reg_pass(:info, content = {_, _, line}, data) do
    case Line.parse(line) do
      %Line{command: err_PASSWDMISMATCH()} ->
        {:next_state, :error, {:invalid_password, data.args.pass}}
      line ->
        #{:keep_state_and_data, [:postpone, {:state_timeout, @reply_timeout, nil}]}
        handle_common(:reg_pass, :info, content, data)
    end
  end

  def reg_pass(:state_timeout, _, data) do
    {:next_state, :reg_nick, data, @internal}
  end

  def reg_pass(type, content, data) do
    handle_common(:reg_pass, type, content, data)
  end

  # --- Registration: NICKNAME

  @doc false
  def reg_nick(:internal, nick, data) do
    case socksend(data, ['NICK ', nick || data.args.nick]) do
      :ok -> {:keep_state, %State{data | nick: nick}, {:state_timeout, @reply_timeout, nil}}
      error -> to_disconnected(error, data)
    end
  end

  def reg_nick(:info, content = {_, _, line}, data) do
    case Line.parse(line) do
      %Line{command: cmd} when cmd in [err_NICKNAMEINUSE(), err_NICKCOLLISION()] ->
        new_nick = data.args.nick <> to_string(:random.uniform(9999))
        {:keep_state, data, {:next_event, :internal, new_nick}}
      line = %Line{command: cmd} when cmd in [err_ERRONEUSNICKNAME(), err_NONICKNAMEGIVEN()] ->
        {:next_state, :error, data, {:next_event, :internal, {:invalid_nickname, data.args.nick, line}}}
      line ->
        #{:keep_state_and_data, :postpone}
        handle_common(:reg_nick, :info, content, data)
    end
  end

  def reg_nick(:state_timeout, _, data) do
    {:next_state, :reg_user, data, @internal}
  end

  def reg_nick(type, content, data) do
    handle_common(:reg_nick, type, content, data)
  end

  # --- Registration: USER

  @doc false
  def reg_user(:internal, _, data) do
    user = List.flatten(['USER ', data.args.user, ' 0 * :', data.args.name])
    case socksend(data, user) do
      :ok ->
        {:next_state, :cap_req, data, @internal}
      error ->
        to_disconnected(error, data)
    end
  end

  #def reg_user(:state_timeout, _, data) do
  #  {:next_state, :welcome, data, {:state_timeout, @registration_timeout, nil}}
  #end

  def reg_user(type, content, data) do
    handle_common(:reg_user, type, content, data)
  end

  @doc false
  def cap_req(:internal, _, data = %{server_capabs: []}) do
    {:next_state, :welcome, data}
  end

  def cap_req(:internal, _, data) do
    capabs = data.args.capabs ++ @support_capabs
    req = Enum.filter(@support_capabs, fn(capab) -> Enum.member?(data.server_capabs, capab) end)
          |> Enum.uniq()
          |> Enum.join(" ")
    case socksend(data, ['CAP REQ :', String.to_charlist(req)]) do
      :ok -> {:next_state, :cap_wait_ack, data}
      error -> to_disconnected(error, data)
    end
  end

  def cap_req(type, content, data) do
    handle_common(:cap_req, type, content, data)
  end

  @doc false
  def cap_wait_ack(:enter, _, _) do
    {:keep_state_and_data, {:state_timeout, @reply_timeout, nil}}
  end

  # FIXME: Support multiline ACK/NACK
  def cap_wait_ack(:info, content = {_, _, line}, data) do
    case Line.parse(line) do
      %Line{command: "CAP", args: [_, "ACK", capabs]} ->
        capabs = String.split(capabs, " ")
        {:keep_state, %State{data | capabs: capabs}, {:next_event, :internal, :end}}
      %Line{command: "CAP", args: [_, "NACK", capabs]} ->
        capabs = String.split(capabs, " ")
        {:keep_state, %State{data | capabs: data.capabs -- capabs}, {:next_event, :internal, :end}}
      line ->
        handle_common(:cap_wait_ack, :info, content, data)
    end
  end

  def cap_wait_ack(:internal, :end, data) do
    case socksend(data, 'CAP END') do
      :ok -> {:next_state, :welcome, data}
      error -> to_disconnected(error, data)
    end
  end

  # --- REGISTRATION: Welcome

  @doc false
  def welcome(:enter, _, data) do
    {:keep_state_and_data, {:state_timeout, @registration_timeout, nil}}
  end

  @welcome_numeric [rpl_WELCOME, rpl_YOURHOST, rpl_CREATED, rpl_MYINFO, rpl_ISUPPORT]
  def welcome(:info, content = {module, socket, line}, data) do
    case Line.parse(line) do
      l = %Line{command: err_NOMOTD()} ->
        {:next_state, :registered, %State{data | motd: []}}
      l = %Line{command: rpl_MOTDSTART()} ->
        {:next_state, :motd, data, [:postpone]}
      l = %Line{command: rpl_WELCOME(), source: source, args: [nick, _]} ->
        {:keep_state, %State{data | nick: nick, welcome: [l | data.welcome], server: source}, {:state_timeout, @reply_timeout, nil}}
      l = %Line{command: rpl_MYINFO(), source: source, args: [_, _, version, umodes, cmodes | rest]} ->
        cmodes_with_params = case rest do
          [] -> nil
          [c] -> c
        end
        data = %State{data | welcome: [l | data.welcome], server_version: version, server_umodes: umodes,
          server_cmodes: cmodes, server_cmodes_with_params: cmodes_with_params}
        {:keep_state, data, {:state_timeout, @reply_timeout, nil}}
      l = %Line{command: rpl_ISUPPORT(), args: [_ | isupport]} ->
        supports = Irc.Parser.Isupport.parse(isupport, data.isupport)
        {:keep_state, %State{data | isupport: supports}, {:state_timeout, @reply_timeout, nil}}
      l = %Line{command: cmd} ->
        #{:keep_state, %State{data | welcome: [l | data.welcome]}, {:state_timeout, @reply_timeout, nil}}
        handle_common(:welcome, :info, content, data)
    end
  end

  def welcome(:state_timeout, _, data) do
    to_disconnected(:registration_timeout, data)
  end

  def welcome(type, content, data) do
    handle_common(:welcome, type, content, data)
  end

  # --- Registration: MOTD

  @doc false
  def motd(:enter, _, data) do
    {:keep_state_and_data, {:state_timeout, @reply_timeout, nil}}
  end

  def motd(:info, {_, _, line}, data) do
    case Line.parse(line) do
      %Line{command: rpl_MOTDSTART(), args: [_, line]} ->
        {:keep_state, %State{data | motd: [line]}, {:state_timeout, @reply_timeout, nil}}
      %Line{command: err_NOMOTD()} ->
        {:next_state, :registered, %State{data | motd: []}}
      %Line{command: rpl_MOTD(), args: [_, line]} ->
        {:keep_state, %State{data | motd: [line | data.motd]}, {:state_timeout, @reply_timeout, nil}}
      %Line{command: rpl_ENDOFMOTD(), args: [_, line]} ->
        {:next_state, :registered, %State{data | motd: [line | data.motd]}}
      line ->
        {:keep_state_and_data, :postpone}
    end
  end

  def motd(:state_timeout, _, data) do
    to_disconnected(:motd_timeout, data)
  end

  def motd(type, content, data) do
    handle_common(:motd, type, content, data)
  end

  # --- Registered

  defp to_info(data, state \\ nil) do
    data
    |> Map.from_struct()
    |> Map.take([:nick, :modes, :server, :server_version, :server_umodes, :server_cmodes, :server_cmodes_with_params, :capabs, :isupport, :motd])
    |> Map.put(:__struct__, __MODULE__)
  end

  @conn_ping_timeout {:state_timeout, :timer.seconds(30), :ping}
  @conn_pong_timeout {:state_timeout, :timer.seconds(30), :pong}

  @doc false
  def registered(:enter, _, data) do
    data = %State{data | welcome: Enum.reverse(data.welcome),
      motd: Enum.reverse(data.motd),
      welcomed: true
    }
    msg = {:irc_conn_up, self(), to_info(data, :registered)}
    send(data.process, msg)
    Logger.info("#{inspect(data)} connected and registered")
    {:next_state, :registered, data, @conn_ping_timeout}
  end

  def registered(:info, {_, _, line}, data) do
    line = Line.parse(line)
    Logger.debug "#{inspect(data)} <<< #{inspect(line)}"
    case process_line(line, data) do
      :ignore ->
        msg = {:irc_conn_line, self(), line}
        send(data.process, msg)
        :keep_state_and_data
      return ->
        return
    end
  end

  def registered({:call, ref}, {:send, line}, data) do
    case socksend(data, line) do
      :ok -> {:keep_state_and_data, [{:reply, ref, :ok}, @conn_ping_timeout]}
      error -> {:next_state, :disconnected, data, [{:reply, :ref, {:error, error}}, {:next_event, :internal, error}]}
    end
  end

  def registered(:cast, {:send, line}, data) do
    case socksend(data, line) do
      :ok -> {:keep_state_and_data, @conn_ping_timeout}
      error -> to_disconnected(error, data)
    end
  end

  def registered(:state_timeout, :ping, data) do
    case socksend(data, [?P, ?I, ?N, ?G, 0x20, String.to_charlist(data.server)]) do
      :ok -> {:keep_state_and_data, @conn_pong_timeout}
      error -> to_disconnected(error, data)
    end
  end

  def registered({:call, ref}, :info, data) do
    {:keep_state_and_data, {:reply, ref, {:connected, to_info(data)}}}
  end

  def registered(:state_timeout, :pong, data) do
    to_disconnected({:irc_error, {:timeout, :pang}}, data)
  end

  def registered(type, content, data) do
    handle_common(:registered, type, content, data)
  end

  @doc false
  def process_line(%Line{command: "KILL", source: source, args: [nick, reason]}, data = %{nick: nick}) do
    to_disconnected({:killed, source, reason}, data)
  end

  def process_line(%Line{command: "QUIT", source: source, args: [reason]}, data = %{nick: nick}) do
    if String.starts_with?(source, nick<>"!") do
      to_disconnected({:quit, source, reason}, data)
    else
      :ignore
    end
  end

  def process_line(%Line{command: "ERROR", args: args}, data) do
    to_disconnected({:irc_error, Enum.join(args, " ")}, data)
  end

  def process_line(%Line{command: "PONG", args: [server | _]}, data = %{server: server}) do
    {:keep_state_and_data, @conn_ping_timeout}
  end

  def process_line(%Line{command: "PING", args: args}, data = %{server: server}) do
    case socksend(data, [?P, ?O, ?N, ?G, 0x20, ?:, args |> Enum.join(" ")]) do
      :ok -> {:keep_state_and_data, @conn_ping_timeout}
      error -> to_disconnected(error, data)
    end
  end

  def process_line(%Line{command: "MODE", args: [nick, changes]}, data = %{nick: nick}) do
    modes = Irc.Parser.Mode.changes(changes, data.modes)
    send(data.process, {:irc_conn_modes, self(), changes, data.modes, modes})
    {:keep_state, %State{data | modes: modes}}
  end

  def process_line(%Line{command: "NICK", args: [new_nick]}, data = %{nick: nick}) do
    send(data.process, {:irc_conn_nick, self(), nick, new_nick})
    {:keep_state, %State{data | nick: nick}}
  end

  def process_line(line, _) do
    :ignore
  end

  # Disconnected state

  @doc false
  def disconnected(:enter, from, data) do
    Logger.debug "#{inspect data} entering disconnected state"
    :keep_state_and_data
  end

  def disconnect(:internal, error, data = %{args: %{reconnect: false}}) do
    {:next_state, :error, data, {:next_event, :internal, error}}
  end

  def disconnected(:internal, :disconnected, _) do
    :keep_state_and_data
  end

  def disconnected(:internal, error, data) do
    {delay, backoff} = :backoff.fail(data.backoff)
    send(data.process, {:irc_conn_down, self(), error, delay})
    data = if data.socket do
      data.sockmodule.close(data.socket)
      %State{data | socket: nil, sockmodule: nil}
    else
      data
    end
    data = %State{data | welcomed: false, server: nil, nick: nil, welcome: [], motd: [], isupport: %{}, backoff: backoff}
    Logger.error("#{inspect data} - #{inspect error} - (reconnecting in #{inspect delay})")
    {:keep_state, data, {:state_timeout, delay, error}}
  end

  def disconnected({:call, ref}, :reconnect, data) do
    {:next_state, :connect, data, [@internal, {:reply, ref, :ok}]}
  end

  def disconnected({:call, ref}, :info, data) do
    {:keep_state_and_data, {:reply, ref, :disconnected}}
  end

  def disconnected({:call, ref}, {:disconnect, false, _}, data) do
    {:keep_state_and_data, [{:state_timeout, :infinity, :disconnect}, {:reply, ref, {:error, :not_connected}}]}
  end

  def disconnected(:state_timeout, _error, data) do
    {:next_state, :connect, data, @internal}
  end

  def disconnected(:info, {_, _, _}, data) do
    :keep_state_and_data
  end

  def disconnected(:info, {closed, socket}, data) when closed in [:tcp_closed, :ssl_closed] do
    :keep_state_and_data
  end

  def disconnected(type, content, data) do
    handle_common(:disconnected, type, content, data)
  end

  # --- Fatal error state

  @doc false
  def error(:internal, error, data) do
    send(data.process, {:irc_conn_error, self(), error})
    {:stop, %State{data | errored: true}, error}
  end

  # --- Common defaults

  @doc false
  def handle_common(_, :enter, _, _) do
    :keep_state_and_data
  end

  def handle_common(_, {:call, ref}, {:disconnect, stop, quit}, data = %State{socket: socket}) do
    Logger.debug("#{inspect(data)} disconnecting on request (stop:#{inspect stop})")
    if data.sockmodule && data.socket do
      quit = if quit, do: quit, else: ""
      socksend(data, ['QUIT :', quit])
      data.sockmodule.close(socket)
    end
    if stop do
      {:stop_and_reply, :normal, {:reply, ref, :ok}}
    else
      {:next_state, :disconnected, %State{data | socket: nil, sockmodule: nil}, [
        {:reply, ref, :ok},
        {:next_event, :internal, :disconnected},
      ]}
    end
  end

  def handle_common(_, {:call, ref}, {:disconnect, false, _}, data) do
    {:next_state, :disconnected, data, [{:reply, ref, :ok}, {:next_event, :internal, :disconnected}]}
  end

  def handle_common(_, {:call, ref}, {:disconnect, true, _}, _) do
    {:stop_and_reply, :normal, {:reply, ref, :ok}}
  end

  def handle_common(_, {:call, ref}, :info, data) do
    {:keep_state_and_data, {:reply, ref, :connecting}}
  end

  def handle_common(_, {:call, ref}, :reconnect, _) do
    {:keep_state_and_data, {:reply, ref, {:error, :not_disconnected}}}
  end
  def handle_common(_, {:call, ref}, {:send, _}, _) do
    {:keep_state_and_data, {:reply, ref, {:error, :not_connected}}}
  end

  def handle_common(_, :cast, {:send, _}, _) do
    :keep_state_and_data
  end

  def handle_common(_, :info, {_mod, _sock, line = [?P, ?I, ?N, ?G | _]}, data) do
    line = Line.parse(line)
    arg = Enum.join(line.args, " ")
    case socksend(data, ['PONG :', arg]) do
      :ok -> :keep_state_and_data
      error -> to_disconnected(error, data)
    end
  end

  def handle_common(_, :info, {_mod, _sock, line = [?E, ?R, ?R, ?O, ?R | _]}, data) do
    line = Line.parse(line)
    to_disconnected({:irc_error, Enum.join(line.args, " ")}, data)
  end


  def handle_common(_, :info, {_mod, _sock, _line}, data) do
    {:keep_state_and_data, :postpone}
  end

  def handle_common(_, :info, {closed, socket}, data) when closed in [:tcp_closed, :ssl_closed] do
    {:next_state, :disconnected, %State{data | socket: nil, sockmodule: nil}, @internal}
  end

  @doc false
  def terminate(reason, state, data) do
    unless data.errored do
      send(data.process, {:irc_conn_error, self(), :down})
    end
    Logger.error("#{inspect(data)} terminating in #{inspect(state)}: #{inspect reason}")
  end

  @doc false
  def code_change(_old_vsn, old_state, old_data, _extra) do
    {:ok, old_state, old_data}
  end

  # Send helpers.
  defp socksend(data = %State{sockmodule: module, socket: socket}, line) when is_list(line) do
    Logger.debug("#{inspect data} >>> #{inspect line}")
    module.send(socket, [line | [?\r, ?\n]])
  end


  # Helper to enter to the disconnected state.
  defp to_disconnected(error, data) do
    {:next_state, :disconnected, data, {:next_event, :internal, error}}
  end

  # -- Arguments processing/validation

  # Prepare args (in start)
  defp prepare_args(nick, host, args) do
    args
    |> Keyword.put_new(:nick, nick)
    |> Keyword.put_new(:host, host)
    |> Keyword.put_new(:process, self())
  end

  # Process args (in init)
  defp process_args(args) do
    host = Keyword.get(args, :host, nil)
    port = Keyword.get(args, :port, nil) || 6667
    tls = Keyword.get(args, :tls, nil) || false
    inet = case Keyword.get(args, :inet, nil) do
      4 -> [:inet]
      6 -> [:inet6]
      _ -> []
    end
    ip = Keyword.get(args, :ip, nil)
    ifaddr = Keyword.get(args, :ifaddr, nil)
    connect_timeout = Keyword.get(args, :connect_timeout, @connect_timeout)
    nick = Keyword.get(args, :nick, nil)
    user = Keyword.get(args, :user, nick) || nick
    name = Keyword.get(args, :name, user) || user
    pass = Keyword.get(args, :pass, nil)
    capabs = Keyword.get(args, :capabs, []) || []
    reconnect = Keyword.get(args, :reconnect, true)
    tcp_opts = Keyword.get(args, :tcp_opts, []) || []
    tls_opts = Keyword.get(args, :tls_opts, []) || []

    with \
     {:host, {:ok, host}} <- {:host, parse_host(host)},
     {:port, {:ok, port}} <- {:port, parse_port(port)},
     {:bind, {:ok, bind}} <- {:bind, parse_bind(ip, ifaddr)}
    do
      {:ok, %{
        host: host,
        port: port,
        bind: bind,
        tls: tls,
        capabs: capabs,
        inet: inet,
        nick: nick,
        user: user,
        name: name,
        pass: pass,
        reconnect: reconnect,
        tcp_opts: tcp_opts,
        tls_opts: tls_opts,
        connect_timeout: connect_timeout
      }}
    else
      error -> error
    end
  end

  defp parse_host(host) when is_binary(host) do
    {:ok, host}
  end
  defp parse_host(host), do: {:error, {:invalid_format, :host, inspect(host)}}

  defp parse_port(port) when is_integer(port) when port > 0 and port < 65336 do
    {:ok, port}
  end
  defp parse_port(port), do: {:error, {:invalid_format, :port, inspect(port)}}

  defp parse_bind(ip, _) when is_binary(ip) do
    case :inet.parse_strict_address(String.to_charlist(ip)) do
      {:ok, ip} -> {:ok, [{:ip, ip}]}
      {:error, :einval} -> {:error, {:invalid_format, :ip, inspect(ip)}}
    end
  end
  # TODO: Verify ifaddr is a valid interface
  defp parse_bind(_, ifaddr) when is_binary(ifaddr) do
    {:ok, [{:ifaddr, ifaddr}]}
  end
  defp parse_bind(nil, nil) do
    {:ok, []}
  end
  defp parse_bind(ip, ifaddr) do
    {:error, {:invalid_format, :bind, inspect([ip, ifaddr])}}
  end

  defimpl Inspect, for: State do
    @moduledoc false
    import Inspect.Algebra

    def inspect(struct, _opts) do
      status = cond do
        struct.socket && struct.welcomed -> "registered"
        struct.socket -> "connecting"
        true -> "disconnected"
      end
      tls = if struct.args.tls, do: "+", else: ""
      port = ":#{tls}#{struct.args.port}"
      server = if struct.server do
        "#{struct.args.host}#{port}[#{struct.server}]"
      else
        struct.args.host <> port
      end
      nick = struct.nick || struct.args.nick
      info_string = Enum.join([inspect(self()), status, server, struct.args.user, nick], " ")
      concat(["#Irc.Connection<", info_string, ">"])
    end
  end

end