defmodule GlificWeb.Flows.FlowEditorController do
  @moduledoc """
  The Flow Editor Controller
  """

  use GlificWeb, :controller

  plug(:set_appsignal_namespace)

  alias Glific.{
    Contacts,
    Dialogflow,
    Flows,
    Flows.ContactField,
    Flows.Flow,
    Flows.FlowCount,
    Flows.FlowLabel,
    GCS.GcsWorker,
    Partners,
    Repo,
    Settings,
    Sheets,
    Templates.InteractiveTemplate,
    Templates.InteractiveTemplates,
    Users.User
  }

  defp set_appsignal_namespace(conn, _params) do
    # Configures all actions in this controller to report
    Glific.Appsignal.set_namespace("flow_editor_controller")
    conn
  end

  @doc false
  @spec globals(Plug.Conn.t(), map) :: Plug.Conn.t()
  def globals(conn, _params) do
    conn
    |> json(%{results: []})
  end

  @doc false
  @spec groups(Plug.Conn.t(), map) :: Plug.Conn.t()
  def groups(conn, _params) do
    group_list =
      Glific.Groups.list_groups(
        %{filter: %{organization_id: conn.assigns[:organization_id]}},
        true
      )
      |> Enum.reduce([], fn group, acc ->
        [%{uuid: "#{group.id}", name: group.label, type: "group"} | acc]
      end)

    conn
    |> json(%{results: group_list})
  end

  @doc false
  @spec groups_post(Plug.Conn.t(), map) :: Plug.Conn.t()
  def groups_post(conn, _params) do
    conn
    |> json(%{
      uuid: 0,
      query: nil,
      status: "not-ready",
      count: 0,
      name: "ALERT: PLEASE CREATE NEW GROUP FROM THE ORGANIZATION SETTINGS"
    })
  end

  @doc false
  @spec fields(Plug.Conn.t(), map) :: Plug.Conn.t()
  def fields(conn, _params) do
    fields =
      ContactField.list_contacts_fields(%{
        filter: %{organization_id: conn.assigns[:organization_id]}
      })
      |> Enum.reduce([], fn cf, acc ->
        [%{key: cf.shortcode, name: cf.name, value_type: cf.value_type, label: cf.name} | acc]
      end)

    json(conn, %{results: fields})
  end

  @doc """
  Add Contact fields into the database. The response should be a map with 3 keys
  % { Key: Field name, name: Field display name value_type: type of the value}

  We are not supporting this for now. We will add that in future
  """

  @spec fields_post(Plug.Conn.t(), map) :: Plug.Conn.t()
  def fields_post(conn, params) do
    # need to store this into DB, the value_type will default to text in this case
    # the shortcode is the name, lower cased, and camelized
    ContactField.create_contact_field(%{
      name: params["label"],
      shortcode: String.downcase(params["label"]) |> String.replace(" ", "_"),
      organization_id: conn.assigns[:organization_id]
    })
    |> case do
      {:ok, contact_field} ->
        conn
        |> json(%{
          key: contact_field.shortcode,
          name: contact_field.name,
          label: contact_field.name,
          value_type: contact_field.value_type
        })

      {:error, _} ->
        conn
        |> put_status(400)
        |> json(%{
          error: %{status: 400, message: "Cannot create new field with label #{params["label"]}"}
        })
    end
  end

  @doc """
    Get all the tags so that user can apply them on incoming message.
    We are not supporting this for now. To enable It should return a list of map having
    uuid and name as keys
    [%{uuid: tag.uuid, name: tag.label}]
  """
  @spec labels(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def labels(conn, _params) do
    flow_list = FlowLabel.get_all_flowlabel(conn.assigns[:organization_id])

    json(conn, %{results: flow_list})
  end

  @doc """
  Store a label (new tag) in the system. The return response should be a map of 3 keys.
  [%{uuid: tag.uuid, name: params["name"], count}]

  We are not supporting them for now. We will come back to this in near future
  """
  @spec labels_post(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def labels_post(conn, params) do
    {:ok, flow_label} =
      FlowLabel.create_flow_label(%{
        name: params["name"],
        organization_id: conn.assigns[:organization_id]
      })

    json(conn, %{uuid: flow_label.uuid, name: flow_label.name, count: 0})
  end

  @doc """
  A list of all the communication channels. For Glific it's just WhatsApp.
  We are not supporting them for now. We will come back to this in near future
  """
  @spec channels(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def channels(conn, _params) do
    channels = %{
      results: [
        %{
          uuid: generate_uuid(),
          name: "WhatsApp",
          address: "",
          schemes: ["whatsapp"],
          roles: ["send", "receive"]
        }
      ]
    }

    json(conn, channels)
  end

  @doc """
  A list of all the NLP classifiers. For Glific it's just Dialogflow
  We are not supporting them for now. We will come back to this in near future
  """
  @spec classifiers(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def classifiers(conn, _params) do
    organization_id = conn.assigns[:organization_id]

    classifiers = %{
      results: [
        %{
          uuid: "dialogflow_uuid",
          name: "Dialogflow",
          type: "dialogflow",
          intents: Dialogflow.Intent.get_intent_name_list(organization_id)
        }
      ]
    }

    json(conn, classifiers)
  end

  @doc """
  We are not sure how to use this but this endpoint is required for flow editor.
  Will come back to this in future.
  """
  @spec ticketers(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def ticketers(conn, _params) do
    ticketers = %{results: []}
    json(conn, ticketers)
  end

  @doc """
    We are not using this for now but this is required for flow editor config.
  """
  @spec resthooks(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def resthooks(conn, _params) do
    resthooks = %{results: []}
    json(conn, resthooks)
  end

  @doc """
  A list of all the interactive templates in format that is understood by flow editor
  """
  @spec interactive_templates(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def interactive_templates(conn, _params) do
    results =
      InteractiveTemplates.list_interactives(%{
        filter: %{organization_id: conn.assigns[:organization_id]}
      })
      |> Enum.reduce([], fn interactive, acc ->
        [
          %{
            id: interactive.id,
            name: interactive.label,
            type: interactive.type,
            interactive_content: interactive.interactive_content,
            created_on: interactive.inserted_at,
            modified_on: interactive.updated_at
          }
          | acc
        ]
      end)

    json(conn, %{results: results})
  end

  @doc """
  Fetching single interactive template and returning in format that is understood by flow editor
  or
  Return error Interactive message not found
  """
  @spec interactive_template(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def interactive_template(conn, params) do
    [id] = params["vars"]
    {:ok, id} = Glific.parse_maybe_integer(id)

    case Repo.fetch_by(InteractiveTemplate, %{id: id}) do
      {:ok, interactive_template} ->
        %{
          id: interactive_template.id,
          name: interactive_template.label,
          type: interactive_template.type,
          interactive_content: interactive_template.interactive_content,
          created_on: interactive_template.inserted_at,
          modified_on: interactive_template.updated_at,
          translations: get_interactive_translations(interactive_template.translations)
        }
        |> then(&json(conn, &1))

      {:error, _} ->
        json(conn, %{error: "Interactive message not found"})
    end
  end

  @spec get_interactive_translations(map) :: map()
  defp get_interactive_translations(interactive_translations) do
    language_map = Settings.get_language_id_local_map()

    interactive_translations
    |> Enum.map(fn {language_id, value} -> %{language_map[language_id] => value} end)
    |> Enum.reduce(%{}, fn translation, acc -> Map.merge(acc, translation) end)
  end

  @doc false
  @spec templates(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def templates(conn, _params) do
    results =
      Glific.Templates.list_session_templates(%{
        filter: %{organization_id: conn.assigns[:organization_id], status: "APPROVED"}
      })
      |> Enum.reduce([], fn template, acc ->
        template = Glific.Repo.preload(template, :language)
        language = template.language

        [
          %{
            uuid: template.uuid,
            name: template.label,
            created_on: template.inserted_at,
            modified_on: template.updated_at,
            translations:
              Enum.concat(
                [
                  %{
                    language: language.locale,
                    content: template.body,
                    variable_count: template.number_parameters,
                    status: "approved",
                    channel: %{uuid: "", name: "WhatsApp"}
                  }
                ],
                get_template_translations(template.translations)
              )
          }
          | acc
        ]
      end)

    json(conn, %{results: results})
  end

  @spec get_template_translations(nil | map) :: list()
  defp get_template_translations(nil), do: []

  defp get_template_translations(template_translations) do
    language_map = Settings.get_language_id_local_map()

    template_translations
    |> Enum.reduce([], fn {language_id, translation}, acc ->
      [
        %{
          content: translation["body"],
          variable_count: translation["number_parameters"],
          status: "approved",
          language: language_map[language_id],
          channel: %{uuid: "", name: "WhatsApp"}
        }
        | acc
      ]
    end)
  end

  @doc false
  @spec languages(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def languages(conn, _params) do
    results =
      Glific.Partners.organization(conn.assigns[:organization_id]).languages
      |> Enum.reduce([], fn language, acc ->
        [%{iso: language.locale, name: language.label} | acc]
      end)

    json(conn, %{results: results})
  end

  @doc false
  @spec environment(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def environment(conn, _params) do
    environment = %{}
    json(conn, environment)
  end

  @doc false
  @spec recipients(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def recipients(conn, _params) do
    # we should return only staff contact ids here
    # ideally should only be able to send them an HSM template, so we need
    # this to be fixed in the frontend
    recipients =
      Contacts.list_user_contacts()
      |> Enum.reduce([], fn c, acc ->
        [%{id: "#{c.id}", name: c.name, type: "contact", extra: c.id} | acc]
      end)

    json(conn, %{results: recipients})
  end

  @doc """
  instead of reading a file we can call it directly from Assets.
  We will come back on that when we have more clarity of the use cases
  """
  @spec completion(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def completion(conn, _params) do
    completion =
      File.read!(Path.join(:code.priv_dir(:glific), "data/flows/completion.json"))
      |> Jason.decode!()

    functions =
      File.read!(Path.join(:code.priv_dir(:glific), "data/flows/functions.json"))
      |> Jason.decode!()

    results = %{
      context: completion,
      functions: functions
    }

    json(conn, results)
  end

  @doc """
  This is used to checking if the connection between frontend and backend is established or not.
  """
  @spec activity(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def activity(conn, params) do
    {nodes, segments, recent_messages} =
      FlowCount.get_flow_count_list(params["flow"])
      |> Enum.reduce(
        {%{}, %{}, %{}},
        fn fc, acc ->
          {nodes, segments, recent_messages} = acc

          case fc.type do
            "node" ->
              {Map.put(nodes, fc.uuid, fc.count), segments, recent_messages}

            "exit" ->
              key = "#{fc.uuid}:#{fc.destination_uuid}"

              {
                nodes,
                Map.put(segments, key, fc.count),
                Map.put(recent_messages, key, get_recent_message(fc))
              }

            _ ->
              acc
          end
        end
      )

    activity = %{nodes: nodes, segments: segments, recentMessages: recent_messages}
    json(conn, activity)
  end

  @spec get_recent_message(FlowCount.t()) :: list()
  defp get_recent_message(flow_count) do
    # flow editor shows only last 3 messages. We are just tacking 5 for the safe side.
    flow_count.recent_messages
    |> Enum.map(fn msg -> %{text: msg["message"], sent: msg["date"]} end)
    |> Enum.take(5)
  end

  @doc """
  Let's get all the flows or a latest flow revision
  """
  @spec flows(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def flows(conn, %{"vars" => vars}) do
    results =
      case vars do
        [] ->
          ## We need to fix this before merging this branch
          Flows.list_flows(%{
            filter: %{organization_id: conn.assigns[:organization_id], status: "published"}
          })
          |> Enum.reduce([], fn flow, acc ->
            [
              %{
                uuid: flow.uuid,
                name: flow.name,
                type: flow.flow_type,
                archived: false,
                labels: [],
                expires: 10_080,
                parent_refs: []
              }
              | acc
            ]
          end)

        [flow_uuid] ->
          with {:ok, flow} <-
                 Repo.fetch_by(Flow, %{
                   uuid: flow_uuid,
                   organization_id: conn.assigns[:organization_id]
                 }),
               do: Flow.get_latest_definition(flow.id)
      end

    json(conn, %{results: results})
  end

  @doc """
    Get all or a specific revision for a flow
  """
  @spec revisions(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def revisions(conn, %{"vars" => vars}) do
    case vars do
      [flow_uuid] -> json(conn, Flows.get_flow_revision_list(flow_uuid))
      [flow_uuid, revision_id] -> json(conn, Flows.get_flow_revision(flow_uuid, revision_id))
    end
  end

  @doc """
    Save a revision for a flow and get the revision id
  """
  @spec save_revisions(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def save_revisions(conn, params) do
    revision = Flows.create_flow_revision(params)
    json(conn, %{revision: revision.id})
  end

  @doc """
    Validate media to send as attachment
  """
  @spec validate_media(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def validate_media(conn, params) do
    json(conn, Glific.Messages.validate_media(params["url"], params["type"]))
  end

  @doc false
  @spec attachments_enabled(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def attachments_enabled(conn, _) do
    organization_id = conn.assigns[:organization_id]
    json(conn, %{is_enabled: Partners.attachments_enabled?(organization_id)})
  end

  @doc false
  @spec flow_attachment(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def flow_attachment(conn, %{"media" => media, "extension" => extension} = _params) do
    organization_id = conn.assigns[:organization_id]

    remote_name =
      conn.assigns[:current_user]
      |> remote_name(extension)

    res =
      GcsWorker.upload_media(media.path, remote_name, organization_id)
      |> case do
        {:ok, media} -> %{url: media.url, type: media.type, error: nil}
        {:error, error} -> %{url: nil, error: error}
      end

    json(conn, res)
  end

  @doc false
  @spec sheets(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def sheets(conn, _params) do
    results =
      Sheets.list_sheets(%{
        filter: %{organization_id: conn.assigns[:organization_id], is_active: true}
      })
      |> Enum.reduce([], fn sheet, acc ->
        [
          %{
            id: sheet.id,
            name: sheet.label,
            url: sheet.url
          }
          | acc
        ]
      end)

    json(conn, %{results: results})
  end

  @doc false
  @spec recents(Plug.Conn.t(), nil | maybe_improper_list | map) :: Plug.Conn.t()
  def recents(conn, params) do
    [exit_uuid, destination_uuid, flow_uuid] = params["vars"]

    {:ok, flow_count} =
      Repo.fetch_by(FlowCount, %{
        uuid: exit_uuid,
        destination_uuid: destination_uuid,
        flow_uuid: flow_uuid,
        organization_id: conn.assigns[:organization_id]
      })

    results =
      Enum.reduce(flow_count.recent_messages, [], fn recent_message, acc ->
        [
          %{
            contact: recent_message["contact"],
            operand: recent_message["message"],
            time: recent_message["date"]
          }
          | acc
        ]
      end)

    json(conn, results)
  end

  @doc false
  @spec generate_uuid() :: String.t()
  defp generate_uuid do
    Ecto.UUID.generate()
  end

  @spec remote_name(User.t() | nil, String.t(), Ecto.UUID.t()) :: String.t()
  defp remote_name(user, extension, uuid \\ Ecto.UUID.generate()) do
    {year, week} = Timex.iso_week(Timex.now())
    "outbound/#{year}-#{week}/#{user.name}/#{uuid}.#{extension}"
  end
end