defmodule MvWeb.UserLive.Form do
  use MvWeb, :live_view
  import MvWeb.MemberFormComponent, only: [member_form: 1]

  @impl true
  def render(assigns) do
    ~H"""
    <Layouts.app flash={@flash} current_user={@current_user}>
      <.header>
        {@page_title}
        <:subtitle>{gettext("Use this form to manage user records in your database.")}</:subtitle>
      </.header>

      <.form for={@form} id="user-form" phx-change="validate" phx-submit="save">
        <.input field={@form[:email]} label={gettext("Email")} required type="email" />
        
    <!-- Member Assignment Section -->
        <%= if !@user || !@user.member do %>
          <div class="mt-6 space-y-4">
            <h3 class="text-lg font-medium">{gettext("Member Assignment")}</h3>

            <label class="flex items-center space-x-2">
              <input
                type="radio"
                name="member_assignment_mode"
                value="create_new"
                phx-click="set_member_mode"
                phx-value-mode="create_new"
                checked={@member_assignment_mode == "create_new"}
                class="radio radio-sm"
              />
              <span class="text-sm">
                {gettext("Create new member with custom data")}
              </span>
            </label>

            <label class="flex items-center space-x-2">
              <input
                type="radio"
                name="member_assignment_mode"
                value="assign_existing"
                phx-click="set_member_mode"
                phx-value-mode="assign_existing"
                checked={@member_assignment_mode == "assign_existing"}
                class="radio radio-sm"
              />
              <span class="text-sm">
                {gettext("Assign to existing member")}
              </span>
            </label>

            <%= if @member_assignment_mode == "assign_existing" do %>
              <div class="ml-6 mt-2">
                <.input
                  field={@form[:member_id]}
                  label={gettext("Select Member")}
                  type="select"
                  options={@available_members}
                  prompt={gettext("Choose a member...")}
                />
              </div>
            <% end %>

            <%= if @member_assignment_mode == "create_new" do %>
              <div class="ml-6 mt-4 p-4 bg-gray-50 rounded-lg">
                <%= if @form[:member] do %>
                  <.inputs_for :let={f_member} field={@form[:member]}>
                    <.member_form form={f_member} property_types={@property_types} />
                  </.inputs_for>
                <% else %>
                  <p class="text-sm text-gray-600">{gettext("Member form will be available after saving the user.")}</p>
                <% end %>
              </div>
            <% end %>
          </div>
        <% else %>
          <div class="mt-6 space-y-4">
            <h3 class="text-lg font-medium">{gettext("Member Assignment")}</h3>
            <p class="text-sm text-gray-600">
              {gettext("Edit assigned member")}: {@user.member.first_name} {@user.member.last_name} ({@user.member.email})
            </p>
            <%= if @member_form do %>
              <div class="ml-6 mt-4 p-4 bg-gray-50 rounded-lg">
                <.form for={@member_form} id="member-form" phx-change="validate_member" phx-submit="save_member">
                  <.member_form form={@member_form} property_types={@property_types} />
                  <.button type="submit" variant="primary" class="mt-4">
                    {gettext("Save Member")}
                  </.button>
                </.form>
              </div>
            <% end %>
          </div>
        <% end %>
        
    <!-- Password Section -->
        <div class="mt-6">
          <label class="flex items-center space-x-2">
            <input
              type="checkbox"
              name="set_password"
              phx-click="toggle_password_section"
              checked={@show_password_fields}
              class="checkbox checkbox-sm"
            />
            <span class="text-sm font-medium">
              {if @user, do: gettext("Change Password"), else: gettext("Set Password")}
            </span>
          </label>

          <%= if @show_password_fields do %>
            <div class="mt-4 space-y-4 p-4 bg-gray-50 rounded-lg">
              <.input
                field={@form[:password]}
                label={gettext("Password")}
                type="password"
                required
                autocomplete="new-password"
              />
              
    <!-- Only show password confirmation for new users (register_with_password) -->
              <%= if !@user do %>
                <.input
                  field={@form[:password_confirmation]}
                  label={gettext("Confirm Password")}
                  type="password"
                  required
                  autocomplete="new-password"
                />
              <% end %>

              <div class="text-sm text-gray-600">
                <p><strong>{gettext("Password requirements")}:</strong></p>
                <ul class="list-disc list-inside text-xs mt-1 space-y-1">
                  <li>{gettext("At least 8 characters")}</li>
                  <li>{gettext("Include both letters and numbers")}</li>
                  <li>{gettext("Consider using special characters")}</li>
                </ul>
              </div>

              <%= if @user do %>
                <div class="mt-3 p-3 bg-orange-50 border border-orange-200 rounded">
                  <p class="text-sm text-orange-800">
                    <strong>{gettext("Admin Note")}:</strong> {gettext(
                      "As an administrator, you can directly set a new password for this user using the same secure Ash Authentication system."
                    )}
                  </p>
                </div>
              <% end %>
            </div>
          <% else %>
            <%= if @user do %>
              <div class="mt-4 p-4 bg-blue-50 rounded-lg">
                <p class="text-sm text-blue-800">
                  <strong>{gettext("Note")}:</strong> {gettext(
                    "Check 'Change Password' above to set a new password for this user."
                  )}
                </p>
              </div>
            <% else %>
              <div class="mt-4 p-4 bg-yellow-50 rounded-lg">
                <p class="text-sm text-yellow-800">
                  <strong>{gettext("Note")}:</strong> {gettext(
                    "User will be created without a password. Check 'Set Password' to add one."
                  )}
                </p>
              </div>
            <% end %>
          <% end %>
        </div>

        <.button phx-disable-with={gettext("Saving...")} variant="primary">
          {gettext("Save User")}
        </.button>
        <.button navigate={return_path(@return_to, @user)}>{gettext("Cancel")}</.button>
      </.form>
    </Layouts.app>
    """
  end

  @impl true
  def mount(params, _session, socket) do
    user =
      case params["id"] do
        nil -> nil
        id ->
          user = Ash.get!(Mv.Accounts.User, id, domain: Mv.Accounts)
          |> Ash.load!(:member)
          
          if user.member do
            {:ok, member_with_properties} = Ash.load(user.member, properties: [:property_type])
            %{user | member: member_with_properties}
          else
            user
          end
      end

    action = if is_nil(user), do: gettext("New"), else: gettext("Edit")
    page_title = action <> " " <> gettext("User")

    # Load available members that have no user assigned
    {:ok, available_members} = Mv.Membership.list_members()
    available_members_with_user = Ash.load!(available_members, :user)

    available_member_options =
      available_members_with_user
      |> Enum.filter(fn member -> is_nil(member.user) end)
      |> Enum.map(fn member ->
        {"#{member.first_name} #{member.last_name} (#{member.email})", member.id}
      end)

    # Load PropertyTypes for MemberForm
    {:ok, property_types} = Mv.Membership.list_property_types()
    initial_properties =
      Enum.map(property_types, fn pt ->
        %{
          "property_type_id" => pt.id,
          "value" => %{
            "type" => pt.value_type,
            "value" => nil,
            "_union_type" => Atom.to_string(pt.value_type)
          }
        }
      end)
    member_form = AshPhoenix.Form.for_create(
      Mv.Membership.Member,
      :create_member,
      domain: Mv.Membership,
      as: "member",
      params: %{"properties" => initial_properties},
      forms: [auto?: true]
    ) |> to_form()

    # Initialize member_form for existing users with members
    member_form = if user && user.member do
      {:ok, member_with_properties} = Ash.load(user.member, properties: [:property_type])
      
      existing_properties =
        member_with_properties.properties
        |> Enum.map(& &1.property_type_id)

      is_missing_property = fn i ->
        not Enum.member?(existing_properties, Map.get(i, "property_type_id"))
      end

      params = %{
        "properties" =>
          Enum.map(member_with_properties.properties, fn prop ->
            %{
              "property_type_id" => prop.property_type_id,
              "value" => %{
                "_union_type" => Atom.to_string(prop.value.type),
                "type" => prop.value.type,
                "value" => prop.value.value
              }
            }
          end)
      }

      form =
        AshPhoenix.Form.for_update(
          member_with_properties,
          :update_member,
          domain: Mv.Membership,
          as: "member",
          params: params,
          forms: [auto?: true]
        )

      missing_properties = Enum.filter(initial_properties, is_missing_property)

      Enum.reduce(
        missing_properties,
        form,
        &AshPhoenix.Form.add_form(&2, [:properties], params: &1)
      ) |> to_form()
    else
      member_form
    end

    {:ok,
     socket
     |> assign(:return_to, return_to(params["return_to"]))
     |> assign(user: user)
     |> assign(:page_title, page_title)
     |> assign(:show_password_fields, false)
     |> assign(:member_assignment_mode, "create_new")
     |> assign(:available_members, available_member_options)
     |> assign(:property_types, property_types)
     |> assign(:initial_properties, initial_properties)
     |> assign(:member_form, member_form)
     |> assign_form()}
  end

  defp return_to("show"), do: "show"
  defp return_to(_), do: "index"

  @impl true
  def handle_event("toggle_password_section", _params, socket) do
    show_password_fields = !socket.assigns.show_password_fields

    socket =
      socket
      |> assign(:show_password_fields, show_password_fields)
      |> assign_form()

    {:noreply, socket}
  end

  def handle_event("set_member_mode", %{"mode" => mode}, socket) do
    socket =
      socket
      |> assign(:member_assignment_mode, mode)
      |> assign_form()

    {:noreply, socket}
  end

  def handle_event("validate", %{"user" => user_params, "member" => member_params}, socket) do
    member_form = AshPhoenix.Form.validate(socket.assigns.member_form.source, member_params) |> to_form()
    user_form = AshPhoenix.Form.validate(socket.assigns.form.source, user_params)
    {:noreply, assign(socket, form: user_form, member_form: member_form)}
  end

  def handle_event("validate", %{"user" => user_params}, socket) do
    {:noreply, assign(socket, form: AshPhoenix.Form.validate(socket.assigns.form, user_params))}
  end

  def handle_event("validate_member", %{"member" => member_params}, socket) do
    member_form = AshPhoenix.Form.validate(socket.assigns.member_form.source, member_params) |> to_form()
    {:noreply, assign(socket, member_form: member_form)}
  end

  def handle_event("save_member", %{"member" => member_params}, socket) do
    case AshPhoenix.Form.submit(socket.assigns.member_form.source, params: member_params) do
      {:ok, member} ->
        # Reload the user with updated member
        user = socket.assigns.user |> Ash.load!(:member)
        socket =
          socket
          |> assign(user: user)
          |> put_flash(:info, "Member updated successfully")
        {:noreply, socket}
      {:error, member_form} ->
        {:noreply, assign(socket, member_form: to_form(member_form))}
    end
  end

  def handle_event("save", params, socket) do
    user_params = params["user"] || %{}
    case AshPhoenix.Form.submit(socket.assigns.form, params: user_params) do
      {:ok, user} ->
        notify_parent({:saved, user})
        socket =
          socket
          |> put_flash(:info, "User #{socket.assigns.form.source.type}d successfully")
          |> push_navigate(to: return_path(socket.assigns.return_to, user))
        {:noreply, socket}
      {:error, form} ->
        {:noreply, assign(socket, form: form)}
    end
  end

  defp notify_parent(msg), do: send(self(), {__MODULE__, msg})

  defp assign_form(%{assigns: %{user: user, show_password_fields: show_password_fields, member_assignment_mode: member_assignment_mode, property_types: property_types}} = socket) do
    form =
      if user do
        # For existing users, use admin password action if password fields are shown
        action = if show_password_fields, do: :admin_set_password, else: :update_user

        if member_assignment_mode == "create_new" do
          initial_properties =
            Enum.map(property_types, fn pt ->
              %{
                "property_type_id" => pt.id,
                "value" => %{
                  "type" => pt.value_type,
                  "value" => nil,
                  "_union_type" => Atom.to_string(pt.value_type)
                }
              }
            end)
          params = %{"member" => %{"properties" => initial_properties}}
          AshPhoenix.Form.for_update(user, action,
            as: "user",
            actor: socket.assigns.current_user,
            domain: Mv.Accounts,
            params: params,
            forms: [auto?: true]
          )
        else
          AshPhoenix.Form.for_update(user, action,
            as: "user",
            actor: socket.assigns.current_user,
            domain: Mv.Accounts
          )
        end
      else
        # For new users, use password registration if password fields are shown
        action = if show_password_fields, do: :register_with_password, else: :create_user

        if member_assignment_mode == "create_new" do
          initial_properties =
            Enum.map(property_types, fn pt ->
              %{
                "property_type_id" => pt.id,
                "value" => %{
                  "type" => pt.value_type,
                  "value" => nil,
                  "_union_type" => Atom.to_string(pt.value_type)
                }
              }
            end)
          params = %{"member" => %{"properties" => initial_properties}}
          AshPhoenix.Form.for_create(Mv.Accounts.User, action,
            as: "user",
            actor: socket.assigns.current_user,
            domain: Mv.Accounts,
            accept: [:email, :password, :password_confirmation],
            params: params,
            forms: [auto?: true]
          )
        else
          AshPhoenix.Form.for_create(Mv.Accounts.User, action,
            as: "user",
            actor: socket.assigns.current_user,
            domain: Mv.Accounts,
            accept: if(member_assignment_mode == "assign_existing", do: [:email, :member_id], else: [:email])
          )
        end
      end

    assign(socket, form: to_form(form))
  end

  defp return_path("index", _user), do: ~p"/users"
  defp return_path("show", user), do: ~p"/users/#{user.id}"
end