defmodule Phoenix do
  @moduledoc """
  This is the documentation for the Phoenix project.

  By default, Phoenix applications depend on the following packages
  across these categories.

  ## General

    * [Ecto]( - a language integrated query and
      database wrapper

    * [ExUnit]( - Elixir's built-in test framework

    * [Gettext]( - Internationalization and
      localization through [`gettext`](

    * [Phoenix]( - the Phoenix web framework
      (these docs)

    * [Phoenix PubSub]( - a distributed
      pub/sub system with presence support

    * [Phoenix HTML]( - conveniences for
      working with HTML in Phoenix

    * [Phoenix View]( - a set of functions
      for building `Phoenix.View` and working with template languages such
      as Elixir's own `EEx`

    * [Phoenix LiveView]( - rich,
      real-time user experiences with server-rendered HTML

    * [Phoenix LiveDashboard]( -
      real-time performance monitoring and debugging tools for Phoenix

    * [Plug]( - a specification and conveniences
      for composable modules in between web applications

    * [Swoosh]( - a library for composing,
    delivering and testing emails, also used by `mix phx.gen.auth`

    * [Telemetry Metrics]( - common
      interface for defining metrics based on Telemetry events

  To get started, see our [overview guides](overview.html).
  use Application

  @doc false
  def start(_type, _args) do
    # Warm up caches
    _ = Phoenix.Template.engines()
    _ = Phoenix.Template.format_encoder("index.html")

    # Configure proper system flags from Phoenix only
    if stacktrace_depth = Application.get_env(:phoenix, :stacktrace_depth) do
      :erlang.system_flag(:backtrace_depth, stacktrace_depth)

    if Application.fetch_env!(:phoenix, :logger) do

    children = [
      # Code reloading must be serial across all Phoenix apps
      {DynamicSupervisor, name: Phoenix.Transports.LongPoll.Supervisor, strategy: :one_for_one}

    Supervisor.start_link(children, strategy: :one_for_one, name: Phoenix.Supervisor)

  # TODO v2: swap Poison default with Jason
  # From there we can ditch explicit config for new projects
  @doc """
  Returns the configured JSON encoding library for Phoenix.

  To customize the JSON library, including the following
  in your `config/config.exs`:

      config :phoenix, :json_library, Jason

  def json_library do
    Application.get_env(:phoenix, :json_library, Poison)

  @doc """
  Returns the `:plug_init_mode` that controls when plugs are

  We recommend to set it to `:runtime` in development for
  compilation time improvements. It must be `:compile` in
  production (the default).

  This option is passed as the `:init_mode` to `Plug.Builder.compile/3`.
  def plug_init_mode do
    Application.get_env(:phoenix, :plug_init_mode, :compile)

  defp warn_on_missing_json_library do
    configured_lib = Application.get_env(:phoenix, :json_library)

    cond do
      configured_lib && Code.ensure_loaded?(configured_lib) ->

      configured_lib && not Code.ensure_loaded?(configured_lib) ->
        IO.warn """
        found #{inspect(configured_lib)} in your application configuration
        for Phoenix JSON encoding, but module #{inspect(configured_lib)} is not available.
        Ensure #{inspect(configured_lib)} is listed as a dependency in mix.exs.

      true ->
        IO.warn """
        Phoenix now requires you to explicitly list which engine to use
        for Phoenix JSON encoding. We recommend everyone to upgrade to
        Jason by setting in your config/config.exs:

            config :phoenix, :json_library, Jason

        And then adding {:jason, "~> 1.0"} as a dependency.

        If instead you would rather continue using Poison, then add to
        your config/config.exs:

            config :phoenix, :json_library, Poison