import type { Folder } from "@yaakapp-internal/models";
import { modelTypeLabel, patchModel } from "@yaakapp-internal/models";
import { useMemo } from "react";
import { openFolderSettings } from "../commands/openFolderSettings";
import { openWorkspaceSettings } from "../commands/openWorkspaceSettings";
import { Icon } from "../components/core/Icon";
import { IconTooltip } from "../components/core/IconTooltip";
import { InlineCode } from "../components/core/InlineCode";
import { HStack } from "../components/core/Stacks";
import type { TabItem } from "../components/core/Tabs/Tabs";
import { capitalize } from "../lib/capitalize";
import { showConfirm } from "../lib/confirm";
import { resolvedModelName } from "../lib/resolvedModelName";
import { useHttpAuthenticationSummaries } from "./useHttpAuthentication";
import type { AuthenticatedModel } from "./useInheritedAuthentication";
import { useInheritedAuthentication } from "./useInheritedAuthentication";
import { useModelAncestors } from "./useModelAncestors";

export function useAuthTab<T extends string>(tabValue: T, model: AuthenticatedModel | null) {
  const authentication = useHttpAuthenticationSummaries();
  const inheritedAuth = useInheritedAuthentication(model);
  const ancestors = useModelAncestors(model);
  const parentModel = ancestors[0] ?? null;

  return useMemo<TabItem[]>(() => {
    if (model == null) return [];

    const tab: TabItem = {
      value: tabValue,
      label: "Auth",
      options: {
        value: model.authenticationType,
        items: [
          ...authentication.map((a) => ({
            label: a.label || "UNKNOWN",
            shortLabel: a.shortLabel,
            value: a.name,
          })),
          { type: "separator" },
          {
            label: "Inherit from Parent",
            shortLabel:
              inheritedAuth != null && inheritedAuth.authenticationType !== "none" ? (
                <HStack space={1.5}>
                  {authentication.find((a) => a.name === inheritedAuth.authenticationType)
                    ?.shortLabel ?? "UNKNOWN"}
                  <IconTooltip
                    icon="magic_wand"
                    iconSize="xs"
                    content="Authentication was inherited from an ancestor"
                  />
                </HStack>
              ) : (
                "Auth"
              ),
            value: null,
          },
          { label: "No Auth", shortLabel: "No Auth", value: "none" },
        ],
        itemsAfter: (() => {
          const actions: (
            | { type: "separator"; label: string }
            | { label: string; leftSlot: React.ReactNode; onSelect: () => Promise<void> }
          )[] = [];

          // Promote: move auth from current model up to parent
          if (
            parentModel &&
            model.authenticationType &&
            model.authenticationType !== "none" &&
            (parentModel.authenticationType == null || parentModel.authenticationType === "none")
          ) {
            actions.push(
              { type: "separator", label: "Actions" },
              {
                label: `Promote to ${capitalize(parentModel.model)}`,
                leftSlot: (
                  <Icon
                    icon={parentModel.model === "workspace" ? "corner_right_up" : "folder_up"}
                  />
                ),
                onSelect: async () => {
                  const confirmed = await showConfirm({
                    id: "promote-auth-confirm",
                    title: "Promote Authentication",
                    confirmText: "Promote",
                    description: (
                      <>
                        Move authentication config to{" "}
                        <InlineCode>{resolvedModelName(parentModel)}</InlineCode>?
                      </>
                    ),
                  });
                  if (confirmed) {
                    await patchModel(model, { authentication: {}, authenticationType: null });
                    await patchModel(parentModel, {
                      authentication: model.authentication,
                      authenticationType: model.authenticationType,
                    });

                    if (parentModel.model === "folder") {
                      openFolderSettings(parentModel.id, "auth");
                    } else {
                      openWorkspaceSettings("auth");
                    }
                  }
                },
              },
            );
          }

          // Copy from ancestor: copy auth config down to current model
          const ancestorWithAuth = ancestors.find(
            (a) => a.authenticationType != null && a.authenticationType !== "none",
          );
          if (ancestorWithAuth) {
            if (actions.length === 0) {
              actions.push({ type: "separator", label: "Actions" });
            }
            actions.push({
              label: `Copy from ${modelTypeLabel(ancestorWithAuth)}`,
              leftSlot: (
                <Icon
                  icon={
                    ancestorWithAuth.model === "workspace" ? "corner_right_down" : "folder_down"
                  }
                />
              ),
              onSelect: async () => {
                const confirmed = await showConfirm({
                  id: "copy-auth-confirm",
                  title: "Copy Authentication",
                  confirmText: "Copy",
                  description: (
                    <>
                      Copy{" "}
                      {authentication.find((a) => a.name === ancestorWithAuth.authenticationType)
                        ?.label ?? "authentication"}{" "}
                      config from <InlineCode>{resolvedModelName(ancestorWithAuth)}</InlineCode>?
                      This will override the current authentication but will not affect the{" "}
                      {modelTypeLabel(ancestorWithAuth).toLowerCase()}.
                    </>
                  ),
                });
                if (confirmed) {
                  await patchModel(model, {
                    authentication: { ...ancestorWithAuth.authentication },
                    authenticationType: ancestorWithAuth.authenticationType,
                  });
                }
              },
            });
          }

          return actions.length > 0 ? actions : undefined;
        })(),
        onChange: async (authenticationType) => {
          let authentication: Folder["authentication"] = model.authentication;
          if (model.authenticationType !== authenticationType) {
            authentication = {
              // Reset auth if changing types
            };
          }
          await patchModel(model, { authentication, authenticationType });
        },
      },
    };

    return [tab];
  }, [authentication, inheritedAuth, model, parentModel, tabValue, ancestors]);
}