defmodule MvWeb.GroupLive.Show do
  @moduledoc """
  LiveView for displaying a single group's details.

  ## Features
  - Display group information (name, description, member count)
  - List all members in the group
  - Navigate to edit form
  - Return to groups list
  - Delete group (with confirmation)

  ## Security
  - All users with read permission can view groups
  - Only admin users can edit/delete groups
  """
  use MvWeb, :live_view

  import MvWeb.LiveHelpers, only: [current_actor: 1]
  import MvWeb.Authorization

  alias Mv.Membership

  @impl true
  def mount(_params, _session, socket) do
    {:ok,
     socket
     |> assign(:show_add_member_input, false)
     |> assign(:member_search_query, "")
     |> assign(:available_members, [])
     |> assign(:selected_member_ids, [])
     |> assign(:selected_members, [])
     |> assign(:show_member_dropdown, false)
     |> assign(:focused_member_index, nil)}
  end

  @impl true
  def handle_params(%{"slug" => slug}, _url, socket) do
    actor = current_actor(socket)

    # Check if user can read groups
    if can?(actor, :read, Mv.Membership.Group) do
      load_group_by_slug(socket, slug, actor)
    else
      {:noreply, redirect(socket, to: ~p"/members")}
    end
  end

  defp load_group_by_slug(socket, slug, actor) do
    # Load group with members and member_count
    # Using explicit load ensures efficient preloading of members relationship
    require Ash.Query

    query =
      Mv.Membership.Group
      |> Ash.Query.filter(slug == ^slug)
      |> Ash.Query.load([:members, :member_count])

    case Ash.read_one(query, actor: actor, domain: Mv.Membership) do
      {:ok, nil} ->
        {:noreply,
         socket
         |> put_flash(:error, gettext("Group not found."))
         |> redirect(to: ~p"/groups")}

      {:ok, group} ->
        {:noreply,
         socket
         |> assign(:page_title, group.name)
         |> assign(:group, group)}

      {:error, _error} ->
        {:noreply,
         socket
         |> put_flash(:error, gettext("Failed to load group."))
         |> redirect(to: ~p"/groups")}
    end
  end

  @impl true
  def render(assigns) do
    ~H"""
    <Layouts.app flash={@flash} current_user={@current_user}>
      <%!-- Header with Back button, Name, and Edit/Delete buttons --%>
      <div class="flex items-center justify-between gap-4 pb-4">
        <.button navigate={~p"/groups"} aria-label={gettext("Back to groups list")}>
          <.icon name="hero-arrow-left" class="size-4" />
          {gettext("Back")}
        </.button>

        <h1 class="text-2xl font-bold text-center flex-1">
          {@group.name}
        </h1>

        <div class="flex gap-2">
          <%= if can?(@current_user, :update, Mv.Membership.Group) do %>
            <.button variant="primary" navigate={~p"/groups/#{@group.slug}/edit"}>
              {gettext("Edit")}
            </.button>
          <% end %>
          <%= if can?(@current_user, :destroy, Mv.Membership.Group) do %>
            <.button class="btn-error" phx-click="open_delete_modal">
              {gettext("Delete")}
            </.button>
          <% end %>
        </div>
      </div>

      <%!-- Group Information --%>
      <div class="max-w-2xl space-y-6 mb-6">
        <div>
          <h2 class="text-lg font-semibold mb-2">{gettext("Description")}</h2>
          <div class="border border-base-300 rounded-lg p-4 bg-base-100">
            <%= if @group.description && String.trim(@group.description) != "" do %>
              <p class="whitespace-pre-wrap">{@group.description}</p>
            <% else %>
              <p class="text-base-content/50 italic">{gettext("No description")}</p>
            <% end %>
          </div>
        </div>

        <div>
          <h2 class="text-lg font-semibold mb-2">{gettext("Members")}</h2>
          <div class="border border-base-300 rounded-lg p-4 bg-base-100">
            <p class="mb-4">
              {ngettext(
                "Total: %{count} member",
                "Total: %{count} members",
                @group.member_count || 0,
                count: @group.member_count || 0
              )}
            </p>

            <%= if can?(@current_user, :update, Mv.Membership.Group) do %>
              <div class="mb-4">
                <%= if assigns[:show_add_member_input] do %>
                  <div class="join w-full">
                    <form phx-change="search_members" class="flex-1">
                      <div class="relative">
                        <div class="input input-bordered join-item w-full flex flex-wrap gap-1 items-center py-1 px-2">
                          <%= for member <- @selected_members do %>
                            <span class="badge badge-outline badge flex items-center gap-1">
                              {MvWeb.Helpers.MemberHelpers.display_name(member)}
                              <button
                                type="button"
                                class="btn btn-ghost btn-xs p-0 h-4 w-4 min-h-0"
                                phx-click="remove_selected_member"
                                phx-value-member_id={member.id}
                                aria-label={
                                  gettext("Remove %{name}",
                                    name: MvWeb.Helpers.MemberHelpers.display_name(member)
                                  )
                                }
                              >
                                <.icon name="hero-x-mark" class="size-3" />
                              </button>
                            </span>
                          <% end %>
                          <input
                            type="text"
                            id="member-search-input"
                            role="combobox"
                            phx-hook="ComboBox"
                            phx-focus="show_member_dropdown"
                            phx-debounce="300"
                            phx-window-keydown="member_dropdown_keydown"
                            phx-mounted={JS.focus()}
                            value={@member_search_query}
                            placeholder={
                              if Enum.empty?(@selected_members),
                                do: gettext("Search for a member..."),
                                else: ""
                            }
                            class="flex-1 min-w-[120px] border-0 focus:outline-none bg-transparent"
                            name="member_search"
                            aria-label={gettext("Search for a member")}
                            aria-autocomplete="list"
                            aria-controls="member-dropdown"
                            aria-expanded={to_string(@show_member_dropdown)}
                            aria-activedescendant={
                              if @focused_member_index,
                                do: "member-option-#{@focused_member_index}",
                                else: nil
                            }
                            autocomplete="off"
                          />
                        </div>

                        <%= if length(@available_members) > 0 do %>
                          <div
                            id="member-dropdown"
                            role="listbox"
                            aria-label={gettext("Available members")}
                            class={"absolute z-10 w-full mt-1 bg-base-100 border border-base-300 rounded-lg shadow-lg max-h-60 overflow-auto top-full #{if !@show_member_dropdown, do: "hidden"}"}
                            phx-click-away="hide_member_dropdown"
                          >
                            <%= for {member, index} <- Enum.with_index(@available_members) do %>
                              <div
                                id={"member-option-#{index}"}
                                role="option"
                                tabindex="0"
                                aria-selected={to_string(@focused_member_index == index)}
                                phx-click="select_member"
                                phx-value-id={member.id}
                                data-member-id={member.id}
                                class={[
                                  "px-4 py-3 cursor-pointer border-b border-base-300 last:border-b-0",
                                  if(@focused_member_index == index,
                                    do: "bg-base-300",
                                    else: "hover:bg-base-200"
                                  )
                                ]}
                              >
                                <p class="font-medium">
                                  {MvWeb.Helpers.MemberHelpers.display_name(member)}
                                </p>
                                <p class="text-sm text-base-content/70">
                                  {member.email || gettext("No email")}
                                </p>
                              </div>
                            <% end %>
                          </div>
                        <% end %>
                      </div>
                    </form>
                    <button
                      type="button"
                      class="btn btn-primary join-item"
                      phx-click="add_selected_members"
                      disabled={Enum.empty?(@selected_member_ids)}
                      aria-label={gettext("Add members")}
                    >
                      <.icon name="hero-plus" class="size-5" />
                    </button>
                  </div>
                <% else %>
                  <.button
                    variant="primary"
                    phx-click="show_add_member_input"
                    aria-label={gettext("Add Member")}
                  >
                    {gettext("Add Member")}
                  </.button>
                <% end %>
              </div>
            <% end %>

            <%= if Enum.empty?(@group.members || []) do %>
              <p class="text-base-content/50 italic">{gettext("No members in this group")}</p>
            <% else %>
              <div class="overflow-x-auto">
                <table class="table table-zebra">
                  <thead>
                    <tr>
                      <th>{gettext("Name")}</th>
                      <th>{gettext("Email")}</th>
                      <%= if can?(@current_user, :update, Mv.Membership.Group) do %>
                        <th class="w-0">{gettext("Actions")}</th>
                      <% end %>
                    </tr>
                  </thead>
                  <tbody>
                    <%= for member <- @group.members do %>
                      <tr>
                        <td>
                          <.link
                            navigate={~p"/members/#{member.id}"}
                            class="link link-primary"
                          >
                            {MvWeb.Helpers.MemberHelpers.display_name(member)}
                          </.link>
                        </td>
                        <td>
                          <%= if member.email do %>
                            <a
                              href={"mailto:#{member.email}"}
                              class="text-blue-700 hover:text-blue-800 underline"
                            >
                              {member.email}
                            </a>
                          <% else %>
                            <span class="text-base-content/50 italic">—</span>
                          <% end %>
                        </td>
                        <%= if can?(@current_user, :update, Mv.Membership.Group) do %>
                          <td>
                            <button
                              type="button"
                              class="btn btn-ghost btn-sm text-error"
                              phx-click="remove_member"
                              phx-value-member_id={member.id}
                              aria-label={gettext("Remove member from group")}
                              data-tooltip={gettext("Remove")}
                            >
                              <.icon name="hero-trash" class="size-4" />
                            </button>
                          </td>
                        <% end %>
                      </tr>
                    <% end %>
                  </tbody>
                </table>
              </div>
            <% end %>
          </div>
        </div>
      </div>

      <%!-- Delete Confirmation Modal --%>
      <%= if assigns[:show_delete_modal] do %>
        <dialog id="delete-group-modal" class="modal modal-open" role="dialog">
          <div class="modal-box">
            <h3 class="text-lg font-bold mb-4">{gettext("Delete Group")}</h3>
            <p class="mb-4">
              {gettext("Are you sure you want to delete this group? This action cannot be undone.")}
            </p>
            <%= if @group.member_count && @group.member_count > 0 do %>
              <div class="alert alert-warning mb-4">
                <.icon name="hero-exclamation-triangle" class="size-5" />
                <span>
                  {ngettext(
                    "This group has %{count} member. All member-group associations will be permanently deleted.",
                    "This group has %{count} members. All member-group associations will be permanently deleted.",
                    @group.member_count,
                    count: @group.member_count
                  )}
                </span>
              </div>
            <% end %>
            <div>
              <label for="group-name-confirmation" class="label">
                <span class="label-text">
                  {gettext("To confirm deletion, please enter the group name:")}
                </span>
              </label>
              <div class="p-2 mb-2 font-mono text-lg font-bold break-all rounded bg-base-200">
                {@group.name}
              </div>
              <form phx-change="update_name_confirmation">
                <input
                  id="group-name-confirmation"
                  name="name"
                  type="text"
                  value={@name_confirmation || ""}
                  placeholder={gettext("Enter the group name to confirm")}
                  autocomplete="off"
                  phx-debounce="200"
                  class="w-full input input-bordered"
                />
              </form>
            </div>
            <div class="modal-action">
              <button
                type="button"
                class="btn"
                phx-click="cancel_delete"
                aria-label={gettext("Cancel")}
              >
                {gettext("Cancel")}
              </button>
              <button
                type="button"
                class="btn btn-error"
                phx-click="confirm_delete"
                phx-value-slug={@group.slug}
                disabled={(@name_confirmation || "") != @group.name}
                aria-label={gettext("Delete group")}
              >
                {gettext("Delete")}
              </button>
            </div>
          </div>
        </dialog>
      <% end %>
    </Layouts.app>
    """
  end

  # Delete Modal Events
  @impl true
  def handle_event("open_delete_modal", _params, socket) do
    {:noreply, assign(socket, show_delete_modal: true, name_confirmation: "")}
  end

  @impl true
  def handle_event("cancel_delete", _params, socket) do
    {:noreply,
     socket
     |> assign(:show_delete_modal, false)
     |> assign(:name_confirmation, "")}
  end

  @impl true
  def handle_event("update_name_confirmation", %{"name" => name}, socket) do
    {:noreply, assign(socket, :name_confirmation, name)}
  end

  @impl true
  def handle_event("confirm_delete", %{"slug" => slug}, socket) do
    actor = current_actor(socket)
    group = socket.assigns.group

    # Verify slug matches the group in assigns (prevents tampering)
    if group.slug == slug do
      # Server-side authorization check on the specific group record
      if can?(actor, :destroy, group) do
        handle_delete_confirmation(socket, group, actor)
      else
        {:noreply,
         socket
         |> put_flash(:error, gettext("Not authorized."))
         |> redirect(to: ~p"/groups")}
      end
    else
      {:noreply,
       socket
       |> put_flash(:error, gettext("Group not found."))
       |> redirect(to: ~p"/groups")}
    end
  end

  # Add Member Events
  @impl true
  def handle_event("show_add_member_input", _params, socket) do
    # Reload group to ensure we have the latest members list
    actor = current_actor(socket)
    group = socket.assigns.group
    socket = reload_group(socket, group.slug, actor)

    {:noreply,
     socket
     |> assign(:show_add_member_input, true)
     |> assign(:member_search_query, "")
     |> assign(:available_members, [])
     |> assign(:selected_member_ids, [])
     |> assign(:selected_members, [])
     |> assign(:show_member_dropdown, false)
     |> assign(:focused_member_index, nil)}
  end

  @impl true
  def handle_event("show_member_dropdown", _params, socket) do
    # Reload group to ensure we have the latest members list before filtering
    actor = current_actor(socket)
    group = socket.assigns.group
    socket = reload_group(socket, group.slug, actor)

    # Load available members with empty query when input is focused
    socket =
      socket
      |> load_available_members("")
      |> assign(:show_member_dropdown, true)
      |> assign(:focused_member_index, nil)

    {:noreply, socket}
  end

  @impl true
  def handle_event("hide_member_dropdown", _params, socket) do
    {:noreply, assign(socket, show_member_dropdown: false, focused_member_index: nil)}
  end

  @impl true
  def handle_event("member_dropdown_keydown", %{"key" => "ArrowDown"}, socket) do
    return_if_dropdown_closed(socket, fn ->
      max_index = length(socket.assigns.available_members) - 1
      current = socket.assigns.focused_member_index

      new_index =
        case current do
          nil -> 0
          index when index < max_index -> index + 1
          _ -> current
        end

      {:noreply, assign(socket, focused_member_index: new_index)}
    end)
  end

  @impl true
  def handle_event("member_dropdown_keydown", %{"key" => "ArrowUp"}, socket) do
    return_if_dropdown_closed(socket, fn ->
      current = socket.assigns.focused_member_index

      new_index =
        case current do
          nil -> 0
          0 -> 0
          index -> index - 1
        end

      {:noreply, assign(socket, focused_member_index: new_index)}
    end)
  end

  @impl true
  def handle_event("member_dropdown_keydown", %{"key" => "Enter"}, socket) do
    return_if_dropdown_closed(socket, fn ->
      select_focused_member(socket)
    end)
  end

  @impl true
  def handle_event("member_dropdown_keydown", %{"key" => "Escape"}, socket) do
    return_if_dropdown_closed(socket, fn ->
      {:noreply, assign(socket, show_member_dropdown: false, focused_member_index: nil)}
    end)
  end

  @impl true
  def handle_event("member_dropdown_keydown", _params, socket) do
    # Ignore other keys
    {:noreply, socket}
  end

  @impl true
  def handle_event("search_members", %{"member_search" => query}, socket) do
    # Reload group to ensure we have the latest members list before filtering
    actor = current_actor(socket)
    group = socket.assigns.group
    socket = reload_group(socket, group.slug, actor)

    socket =
      socket
      |> assign(:member_search_query, query)
      |> load_available_members(query)
      |> assign(:show_member_dropdown, true)
      |> assign(:focused_member_index, nil)

    {:noreply, socket}
  end

  @impl true
  def handle_event("select_member", %{"id" => member_id}, socket) do
    # Check if member is already selected
    if member_id in socket.assigns.selected_member_ids do
      {:noreply, socket}
    else
      # Find the selected member
      selected_member = Enum.find(socket.assigns.available_members, &(&1.id == member_id))

      if selected_member do
        socket =
          socket
          |> assign(:selected_member_ids, [member_id | socket.assigns.selected_member_ids])
          |> assign(:selected_members, [selected_member | socket.assigns.selected_members])
          |> assign(:member_search_query, "")
          |> assign(:show_member_dropdown, false)
          |> assign(:focused_member_index, nil)

        {:noreply, socket}
      else
        {:noreply, socket}
      end
    end
  end

  @impl true
  def handle_event("remove_selected_member", %{"member_id" => member_id}, socket) do
    socket =
      socket
      |> assign(:selected_member_ids, List.delete(socket.assigns.selected_member_ids, member_id))
      |> assign(
        :selected_members,
        Enum.reject(socket.assigns.selected_members, &(&1.id == member_id))
      )

    {:noreply, socket}
  end

  @impl true
  def handle_event("add_selected_members", _params, socket) do
    actor = current_actor(socket)
    group = socket.assigns.group

    # Server-side authorization check
    if can?(actor, :update, group) do
      perform_add_members(socket, group, socket.assigns.selected_member_ids, actor)
    else
      {:noreply,
       socket
       |> put_flash(:error, gettext("Not authorized."))
       |> redirect(to: ~p"/groups/#{group.slug}")}
    end
  end

  @impl true
  def handle_event("remove_member", %{"member_id" => member_id}, socket) do
    actor = current_actor(socket)
    group = socket.assigns.group

    # Server-side authorization check
    if can?(actor, :update, group) do
      perform_remove_member(socket, group, member_id, actor)
    else
      {:noreply,
       socket
       |> put_flash(:error, gettext("Not authorized."))
       |> redirect(to: ~p"/groups/#{group.slug}")}
    end
  end

  # Helper functions
  defp return_if_dropdown_closed(socket, fun) do
    if socket.assigns.show_member_dropdown do
      fun.()
    else
      {:noreply, socket}
    end
  end

  defp select_focused_member(socket) do
    case socket.assigns.focused_member_index do
      nil ->
        {:noreply, socket}

      index ->
        select_member_by_index(socket, index)
    end
  end

  defp select_member_by_index(socket, index) do
    case Enum.at(socket.assigns.available_members, index) do
      nil ->
        {:noreply, socket}

      member ->
        add_member_to_selection(socket, member)
    end
  end

  defp add_member_to_selection(socket, member) do
    # Check if member is already selected
    if member.id in socket.assigns.selected_member_ids do
      {:noreply, socket}
    else
      socket =
        socket
        |> assign(:selected_member_ids, [member.id | socket.assigns.selected_member_ids])
        |> assign(:selected_members, [member | socket.assigns.selected_members])
        |> assign(:member_search_query, "")
        |> assign(:show_member_dropdown, false)
        |> assign(:focused_member_index, nil)

      {:noreply, socket}
    end
  end

  defp load_available_members(socket, query) do
    require Ash.Query

    base_query = available_members_base_query(query)
    limited_query = Ash.Query.limit(base_query, 10)
    actor = current_actor(socket)

    case Ash.read(limited_query, actor: actor, domain: Mv.Membership) do
      {:ok, members} ->
        current_member_ids = group_member_ids_set(socket.assigns.group)

        filtered_members =
          Enum.reject(members, fn member ->
            MapSet.member?(current_member_ids, member.id)
          end)

        assign(socket, available_members: filtered_members)

      {:error, _} ->
        assign(socket, available_members: [])
    end
  end

  defp available_members_base_query(query) do
    search_query = if query && String.trim(query) != "", do: String.trim(query), else: nil

    if search_query do
      Mv.Membership.Member
      |> Ash.Query.for_read(:search, %{query: search_query})
    else
      Mv.Membership.Member
      |> Ash.Query.new()
    end
  end

  defp group_member_ids_set(group) do
    cond do
      is_list(group.members) and group.members != [] ->
        group.members
        |> Enum.map(& &1.id)
        |> MapSet.new()

      is_list(group.members) ->
        MapSet.new()

      true ->
        MapSet.new()
    end
  end

  defp perform_add_members(socket, group, member_ids, actor) when is_list(member_ids) do
    # Add all members in a transaction-like manner
    results =
      Enum.map(member_ids, fn member_id ->
        Membership.create_member_group(
          %{member_id: member_id, group_id: group.id},
          actor: actor
        )
      end)

    # Check for errors
    errors = Enum.filter(results, &match?({:error, _}, &1))

    if Enum.empty?(errors) do
      handle_successful_add_members(socket, group, actor)
    else
      handle_failed_add_members(socket, group, errors, actor)
    end
  end

  defp perform_add_members(socket, _group, _member_ids, _actor) do
    {:noreply,
     socket
     |> put_flash(:error, gettext("No members selected."))}
  end

  defp handle_successful_add_members(socket, group, actor) do
    socket = reload_group(socket, group.slug, actor)

    {:noreply,
     socket
     |> assign(:show_add_member_input, false)
     |> assign(:member_search_query, "")
     |> assign(:available_members, [])
     |> assign(:selected_member_ids, [])
     |> assign(:selected_members, [])
     |> assign(:show_member_dropdown, false)
     |> assign(:focused_member_index, nil)}
  end

  defp handle_failed_add_members(socket, group, errors, actor) do
    error_messages = extract_error_messages(errors)

    # Still reload to show any successful additions
    socket = reload_group(socket, group.slug, actor)

    {:noreply,
     socket
     |> put_flash(
       :error,
       gettext("Some members could not be added: %{errors}", errors: error_messages)
     )
     |> assign(:show_add_member_input, true)}
  end

  defp extract_error_messages(errors) do
    Enum.map(errors, fn {:error, error} ->
      format_single_error(error)
    end)
    |> Enum.uniq()
    |> Enum.join(", ")
  end

  defp format_single_error(%{errors: [%{message: message}]}) when is_binary(message), do: message

  defp format_single_error(%{errors: [%{field: :member_id, message: message}]})
       when is_binary(message),
       do: message

  defp format_single_error(error), do: format_error(error)

  defp perform_remove_member(socket, group, member_id, actor) do
    require Ash.Query

    # Find the MemberGroup association
    query =
      Mv.Membership.MemberGroup
      |> Ash.Query.filter(member_id == ^member_id and group_id == ^group.id)

    case Ash.read_one(query, actor: actor, domain: Mv.Membership) do
      {:ok, nil} ->
        {:noreply,
         socket
         |> put_flash(:error, gettext("Member is not in this group."))}

      {:ok, member_group} ->
        case Membership.destroy_member_group(member_group, actor: actor) do
          :ok ->
            # Reload group with members and member_count
            socket = reload_group(socket, group.slug, actor)

            {:noreply, socket}

          {:error, error} ->
            error_message = format_error(error)

            {:noreply,
             socket
             |> put_flash(
               :error,
               gettext("Failed to remove member: %{error}", error: error_message)
             )}
        end

      {:error, error} ->
        error_message = format_error(error)

        {:noreply,
         socket
         |> put_flash(
           :error,
           gettext("Failed to remove member: %{error}", error: error_message)
         )}
    end
  end

  defp reload_group(socket, slug, actor) do
    require Ash.Query

    query =
      Mv.Membership.Group
      |> Ash.Query.filter(slug == ^slug)
      |> Ash.Query.load([:members, :member_count])

    case Ash.read_one(query, actor: actor, domain: Mv.Membership) do
      {:ok, group} ->
        assign(socket, :group, group)

      {:error, _} ->
        socket
    end
  end

  defp handle_delete_confirmation(socket, group, actor) do
    if socket.assigns.name_confirmation == group.name do
      perform_group_deletion(socket, group, actor)
    else
      {:noreply,
       socket
       |> put_flash(:error, gettext("Group name does not match."))
       |> assign(:show_delete_modal, true)}
    end
  end

  defp perform_group_deletion(socket, group, actor) do
    case Membership.destroy_group(group, actor: actor) do
      :ok ->
        {:noreply,
         socket
         |> put_flash(:info, gettext("Group deleted successfully."))
         |> redirect(to: ~p"/groups")}

      {:error, error} ->
        error_message = format_error(error)

        {:noreply,
         socket
         |> put_flash(
           :error,
           gettext("Failed to delete group: %{error}", error: error_message)
         )
         |> assign(:show_delete_modal, false)
         |> assign(:name_confirmation, "")}
    end
  end

  defp format_error(%{message: message}) when is_binary(message), do: message
  defp format_error(error), do: inspect(error)
end