import type { Command } from "./registry";
import { PersonaListOverlay } from "../components/PersonaListOverlay";
import { ConfirmOverlay } from "../components/ConfirmOverlay";
import { isReservedPersonaId } from "../../../src/core/types/entities.js";

export const deleteCommand: Command = {
  name: "delete",
  aliases: ["del"],
  description: "*Permanently* delete a persona",
  usage: "/delete [name]",
  
  async execute(args, ctx) {
    if (ctx.ei.activeRoomId() && args.length === 0) {
      const roomId = ctx.ei.activeRoomId()!;
      const room = ctx.ei.getRoom(roomId);
      const displayName = room?.display_name ?? roomId;

      const confirmed = await new Promise<boolean>((resolve) => {
        ctx.showOverlay((hideOverlay, _hideForEditor) => (
          <ConfirmOverlay
            message={`Archive room "${displayName}"?\nThe room will be archived and removed from the list.`}
            onConfirm={() => { hideOverlay(); resolve(true); }}
            onCancel={() => { hideOverlay(); resolve(false); }}
          />
        ), ctx.renderer);
      });

      if (confirmed) {
        await ctx.ei.archiveRoom(roomId);
        ctx.showNotification(`Room "${displayName}" archived`, "info");
      } else {
        ctx.showNotification("Cancelled", "info");
      }
      return;
    }

    const allPersonas = ctx.ei.personas();
    const deletable = allPersonas.filter(p => p.id !== ctx.ei.activePersonaId() && !isReservedPersonaId(p.id));
    
    const confirmAndDelete = async (personaId: string, displayName: string) => {
      const confirmed = await new Promise<boolean>((resolve) => {
        ctx.showOverlay((hideOverlay, _hideForEditor) => (
          <ConfirmOverlay
            message={`Delete "${displayName}"?\nThis cannot be undone.`}
            onConfirm={() => { hideOverlay(); resolve(true); }}
            onCancel={() => { hideOverlay(); resolve(false); }}
          />
        ), ctx.renderer);
      });
      
      if (confirmed) {
        await ctx.ei.deletePersona(personaId);
        ctx.showNotification(`Deleted ${displayName}`, "info");
      } else {
        ctx.showNotification("Cancelled", "info");
      }
    };
    
    if (args.length === 0) {
      if (deletable.length === 0) {
        ctx.showNotification("No personas available to delete", "info");
        return;
      }
      ctx.showOverlay((hideOverlay, _hideForEditor) => (
        <PersonaListOverlay
          personas={deletable}
          activePersonaId={null}
          title="Select persona to delete"
          onSelect={async (personaId) => {
            const persona = deletable.find(p => p.id === personaId);
            hideOverlay();
            await confirmAndDelete(personaId, persona?.display_name ?? personaId);
          }}
          onDismiss={hideOverlay}
        />
      ), ctx.renderer);
      return;
    }
    
    const nameOrAlias = args.join(" ");
    const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
    
    if (!personaId) {
      const roomId = ctx.ei.resolveRoomName(nameOrAlias);
      if (roomId) {
        const room = ctx.ei.getRoom(roomId);
        const displayName = room?.display_name ?? roomId;

        const confirmed = await new Promise<boolean>((resolve) => {
          ctx.showOverlay((hideOverlay, _hideForEditor) => (
            <ConfirmOverlay
              message={`Archive room "${displayName}"?\nThe room will be archived and removed from the list.`}
              onConfirm={() => { hideOverlay(); resolve(true); }}
              onCancel={() => { hideOverlay(); resolve(false); }}
            />
          ), ctx.renderer);
        });

        if (confirmed) {
          await ctx.ei.archiveRoom(roomId);
          ctx.showNotification(`Room "${displayName}" archived`, "info");
        } else {
          ctx.showNotification("Cancelled", "info");
        }
        return;
      }

      ctx.showNotification(`Persona '${nameOrAlias}' not found`, "error");
      return;
    }
    
    if (personaId === ctx.ei.activePersonaId()) {
      ctx.showNotification("Cannot delete active persona. Switch to another first.", "error");
      return;
    }

    if (isReservedPersonaId(personaId)) {
      ctx.showNotification(`Cannot delete reserved persona. Use /archive instead.`, "error");
      return;
    }
    
    const persona = allPersonas.find(p => p.id === personaId);
    await confirmAndDelete(personaId, persona?.display_name ?? nameOrAlias);
  }
};