gc-alexandria/src/lib/stores/userStore.ts

import { writable, get } from "svelte/store";
import type { NostrProfile } from "$lib/utils/nostrUtils";
import type { NDKUser, NDKSigner } from "@nostr-dev-kit/ndk";
import {
  NDKNip07Signer,
  NDKRelayAuthPolicies,
  NDKRelaySet,
  NDKRelay,
} from "@nostr-dev-kit/ndk";
import { getUserMetadata } from "$lib/utils/nostrUtils";
import { ndkInstance, activeInboxRelays, activeOutboxRelays } from "$lib/ndk";
import { loginStorageKey } from "$lib/consts";
import { nip19 } from "nostr-tools";

export interface UserState {
  pubkey: string | null;
  npub: string | null;
  profile: NostrProfile | null;
  relays: { inbox: string[]; outbox: string[] };
  loginMethod: "extension" | "amber" | "npub" | null;
  ndkUser: NDKUser | null;
  signer: NDKSigner | null;
  signedIn: boolean;
}

export const userStore = writable<UserState>({
  pubkey: null,
  npub: null,
  profile: null,
  relays: { inbox: [], outbox: [] },
  loginMethod: null,
  ndkUser: null,
  signer: null,
  signedIn: false,
});

// Helper functions for relay management
function getRelayStorageKey(user: NDKUser, type: "inbox" | "outbox"): string {
  return `${loginStorageKey}/${user.pubkey}/${type}`;
}

function persistRelays(
  user: NDKUser,
  inboxes: Set<NDKRelay>,
  outboxes: Set<NDKRelay>,
): void {
  localStorage.setItem(
    getRelayStorageKey(user, "inbox"),
    JSON.stringify(Array.from(inboxes).map((relay) => relay.url)),
  );
  localStorage.setItem(
    getRelayStorageKey(user, "outbox"),
    JSON.stringify(Array.from(outboxes).map((relay) => relay.url)),
  );
}

function getPersistedRelays(user: NDKUser): [Set<string>, Set<string>] {
  const inboxes = new Set<string>(
    JSON.parse(localStorage.getItem(getRelayStorageKey(user, "inbox")) ?? "[]"),
  );
  const outboxes = new Set<string>(
    JSON.parse(
      localStorage.getItem(getRelayStorageKey(user, "outbox")) ?? "[]",
    ),
  );

  return [inboxes, outboxes];
}

async function getUserPreferredRelays(
  ndk: any,
  user: NDKUser,
      fallbacks: readonly string[] = [...get(activeInboxRelays), ...get(activeOutboxRelays)],
): Promise<[Set<NDKRelay>, Set<NDKRelay>]> {
  const relayList = await ndk.fetchEvent(
    {
      kinds: [10002],
      authors: [user.pubkey],
    },
    {
      groupable: false,
      skipVerification: false,
      skipValidation: false,
    },
    NDKRelaySet.fromRelayUrls(fallbacks, ndk),
  );

  const inboxRelays = new Set<NDKRelay>();
  const outboxRelays = new Set<NDKRelay>();

  if (relayList == null) {
    const relayMap = await window.nostr?.getRelays?.();
    Object.entries(relayMap ?? {}).forEach(
      ([url, relayType]: [string, any]) => {
        const relay = new NDKRelay(
          url,
          NDKRelayAuthPolicies.signIn({ ndk }),
          ndk,
        );
        if (relayType.read) inboxRelays.add(relay);
        if (relayType.write) outboxRelays.add(relay);
      },
    );
  } else {
    relayList.tags.forEach((tag: string[]) => {
      switch (tag[0]) {
        case "r":
          inboxRelays.add(
            new NDKRelay(tag[1], NDKRelayAuthPolicies.signIn({ ndk }), ndk),
          );
          break;
        case "w":
          outboxRelays.add(
            new NDKRelay(tag[1], NDKRelayAuthPolicies.signIn({ ndk }), ndk),
          );
          break;
        default:
          inboxRelays.add(
            new NDKRelay(tag[1], NDKRelayAuthPolicies.signIn({ ndk }), ndk),
          );
          outboxRelays.add(
            new NDKRelay(tag[1], NDKRelayAuthPolicies.signIn({ ndk }), ndk),
          );
          break;
      }
    });
  }

  return [inboxRelays, outboxRelays];
}

// --- Unified login/logout helpers ---

export const loginMethodStorageKey = "alexandria/login/method";

function persistLogin(user: NDKUser, method: "extension" | "amber" | "npub") {
  localStorage.setItem(loginStorageKey, user.pubkey);
  localStorage.setItem(loginMethodStorageKey, method);
}

function getPersistedLoginMethod(): "extension" | "amber" | "npub" | null {
  return (
    (localStorage.getItem(loginMethodStorageKey) as
      | "extension"
      | "amber"
      | "npub") ?? null
  );
}

function clearLogin() {
  localStorage.removeItem(loginStorageKey);
  localStorage.removeItem(loginMethodStorageKey);
}

/**
 * Login with NIP-07 browser extension
 */
export async function loginWithExtension() {
  const ndk = get(ndkInstance);
  if (!ndk) throw new Error("NDK not initialized");
  // Only clear previous login state after successful login
  const signer = new NDKNip07Signer();
  const user = await signer.user();
  const npub = user.npub;
  const profile = await getUserMetadata(npub);
  // Fetch user's preferred relays
  const [persistedInboxes, persistedOutboxes] = getPersistedRelays(user);
  for (const relay of persistedInboxes) {
    ndk.addExplicitRelay(relay);
  }
  const [inboxes, outboxes] = await getUserPreferredRelays(ndk, user);
  persistRelays(user, inboxes, outboxes);
  ndk.signer = signer;
  ndk.activeUser = user;
  userStore.set({
    pubkey: user.pubkey,
    npub,
    profile,
    relays: {
      inbox: Array.from(inboxes ?? persistedInboxes).map((relay) => relay.url),
      outbox: Array.from(outboxes ?? persistedOutboxes).map(
        (relay) => relay.url,
      ),
    },
    loginMethod: "extension",
    ndkUser: user,
    signer,
    signedIn: true,
  });
  clearLogin();
  localStorage.removeItem("alexandria/logout/flag");
  persistLogin(user, "extension");
}

/**
 * Login with Amber (NIP-46)
 */
export async function loginWithAmber(amberSigner: NDKSigner, user: NDKUser) {
  const ndk = get(ndkInstance);
  if (!ndk) throw new Error("NDK not initialized");
  // Only clear previous login state after successful login
  const npub = user.npub;
  const profile = await getUserMetadata(npub, true); // Force fresh fetch
  const [persistedInboxes, persistedOutboxes] = getPersistedRelays(user);
  for (const relay of persistedInboxes) {
    ndk.addExplicitRelay(relay);
  }
  const [inboxes, outboxes] = await getUserPreferredRelays(ndk, user);
  persistRelays(user, inboxes, outboxes);
  ndk.signer = amberSigner;
  ndk.activeUser = user;
  userStore.set({
    pubkey: user.pubkey,
    npub,
    profile,
    relays: {
      inbox: Array.from(inboxes ?? persistedInboxes).map((relay) => relay.url),
      outbox: Array.from(outboxes ?? persistedOutboxes).map(
        (relay) => relay.url,
      ),
    },
    loginMethod: "amber",
    ndkUser: user,
    signer: amberSigner,
    signedIn: true,
  });
  clearLogin();
  localStorage.removeItem("alexandria/logout/flag");
  persistLogin(user, "amber");
}

/**
 * Login with npub (read-only)
 */
export async function loginWithNpub(pubkeyOrNpub: string) {
  const ndk = get(ndkInstance);
  if (!ndk) throw new Error("NDK not initialized");
  // Only clear previous login state after successful login
  let hexPubkey: string;
  if (pubkeyOrNpub.startsWith("npub")) {
    try {
      hexPubkey = nip19.decode(pubkeyOrNpub).data as string;
    } catch (e) {
      console.error("Failed to decode hex pubkey from npub:", pubkeyOrNpub, e);
      throw e;
    }
  } else {
    hexPubkey = pubkeyOrNpub;
  }
  let npub: string;
  try {
    npub = nip19.npubEncode(hexPubkey);
  } catch (e) {
    console.error("Failed to encode npub from hex pubkey:", hexPubkey, e);
    throw e;
  }
  const user = ndk.getUser({ npub });
  const profile = await getUserMetadata(npub);
  ndk.signer = undefined;
  ndk.activeUser = user;
  userStore.set({
    pubkey: user.pubkey,
    npub,
    profile,
    relays: { inbox: [], outbox: [] },
    loginMethod: "npub",
    ndkUser: user,
    signer: null,
    signedIn: true,
  });
  clearLogin();
  localStorage.removeItem("alexandria/logout/flag");
  persistLogin(user, "npub");
}

/**
 * Logout and clear all user state
 */
export function logoutUser() {
  console.log("Logging out user...");
  const currentUser = get(userStore);
  if (currentUser.ndkUser) {
    // Clear persisted relays for the user
    localStorage.removeItem(getRelayStorageKey(currentUser.ndkUser, "inbox"));
    localStorage.removeItem(getRelayStorageKey(currentUser.ndkUser, "outbox"));
  }

  // Clear all possible login states from localStorage
  clearLogin();

  // Also clear any other potential login keys that might exist
  const keysToRemove = [];
  for (let i = 0; i < localStorage.length; i++) {
    const key = localStorage.key(i);
    if (
      key &&
      (key.includes("login") ||
        key.includes("nostr") ||
        key.includes("user") ||
        key.includes("alexandria") ||
        key === "pubkey")
    ) {
      keysToRemove.push(key);
    }
  }

  // Specifically target the login storage key
  keysToRemove.push("alexandria/login/pubkey");
  keysToRemove.push("alexandria/login/method");

  keysToRemove.forEach((key) => {
    console.log("Removing localStorage key:", key);
    localStorage.removeItem(key);
  });

  // Clear Amber-specific flags
  localStorage.removeItem("alexandria/amber/fallback");

  // Set a flag to prevent auto-login on next page load
  localStorage.setItem("alexandria/logout/flag", "true");

  console.log("Cleared all login data from localStorage");

  userStore.set({
    pubkey: null,
    npub: null,
    profile: null,
    relays: { inbox: [], outbox: [] },
    loginMethod: null,
    ndkUser: null,
    signer: null,
    signedIn: false,
  });

  const ndk = get(ndkInstance);
  if (ndk) {
    ndk.activeUser = undefined;
    ndk.signer = undefined;
  }

  console.log("Logout complete");
}