import { get } from "svelte/store";
import { Buffer } from "buffer";
import { fail, wait, post, stretch } from "$lib/utils";
import {
  decrypted,
  password as pw,
  passwordPrompt,
  pin,
  loginRedirect,
} from "$lib/store";
import { goto, invalidate } from "$app/navigation";
import {
  getPublicKey,
  signEvent,
  getEventHash,
  nip04,
  nip06,
  nip19,
} from "nostr-tools";
import { mnemonicToEntropy, entropyToMnemonic } from "@scure/bip39";
import wordlist from "$lib/english";
import { bech32m } from "@scure/base";

const { generateSeedWords, privateKeyFromSeedWords } = nip06;
const { encode, decode, toWords, fromWords } = bech32m;

export let generate = async (user) => {
  if (!get(pin)?.length === 6) return;
  let password = get(pw);

  let salt = crypto.getRandomValues(new Uint8Array(16));
  let mnemonic = generateSeedWords();
  let sk = privateKeyFromSeedWords(mnemonic);

  let bytes = new Uint8Array(
    await crypto.subtle.encrypt(
      { name: "AES-GCM", iv: new Uint8Array(16) },
      await stretch(password, salt),
      Uint8Array.from(Buffer.from(mnemonicToEntropy(mnemonic, wordlist), "hex"))
    )
  );

  user.pubkey = getPublicKey(sk);
  user.cipher = encode("en", toWords(bytes), 180);
  user.salt = Buffer.from(salt).toString("hex");
};

export let encrypt = async ({ message, recipient, user }) => {
  return nip04.encrypt(await getPrivateKey(user), recipient, message);
};

export let decrypt = async ({ event, user }) => {
  let cache = get(decrypted);
  try {
    let { content, pubkey, id } = event;
    if (cache[id]) return cache[id];
    if (pubkey === user.pubkey) pubkey = event.tags[0][1];

    let message = await nip04.decrypt(
      await getPrivateKey(user),
      pubkey,
      content
    );

    cache[id] = Buffer.from(message).toString("utf8");
    decrypted.set(cache);

    return cache[id];
  } catch (e) {
    // console.log(e);
  }
};

function typedArrayToBuffer(array) {
  return array.buffer.slice(
    array.byteOffset,
    array.byteLength + array.byteOffset
  );
}

export let getMnemonic = async (user) => {
  let { cipher, username, salt } = user;
  let password = get(pw);

  if (!password) {
    passwordPrompt.set(true);
  }

  try {
    await post("/password", { password });
  } catch (e) {
    passwordPrompt.set(true);
  }

  await wait(() => !!get(pw));
  password = get(pw);

  let mnemonic, key, seed, entropy, child, privkey;

  entropy = new Uint8Array(
    await crypto.subtle.decrypt(
      { name: "AES-GCM", iv: new Uint8Array(16) },
      await stretch(password, Buffer.from(salt, "hex")),
      Uint8Array.from(fromWords(decode(cipher, 180).words))
    )
  );

  return entropyToMnemonic(entropy, wordlist);
};

let getPrivateKey = async (user) => {
  return privateKeyFromSeedWords(await getMnemonic(user));
};

export let getNsec = async (user) => {
  return nip19.nsecEncode(await getPrivateKey(user));
};

export let sign = async ({ event, user }) => {
  event.id = getEventHash(event);
  event.sig = signEvent(event, await getPrivateKey(user));
};

export let send = (event) => {
  return post("/events", { event });
};

export let reEncryptEntropy = async (user, newPassword) => {
  let { cipher, username, salt } = user;
  let password = get(pw);

  if (!password) {
    passwordPrompt.set(true);
  }

  try {
    await post("/password", { password });
  } catch (e) {
    passwordPrompt.set(true);
  }

  await wait(() => !!get(pw));
  password = get(pw);

  let mnemonic, key, seed, entropy, child, privkey;
  entropy = Buffer.from(
    await crypto.subtle.decrypt(
      { name: "AES-GCM", iv: new Uint8Array(16) },
      await stretch(password, Buffer.from(salt, "hex")),
      Uint8Array.from(fromWords(decode(cipher, 180).words))
    ),
    "hex"
  ).toString("hex");

  let bytes = new Uint8Array(
    await crypto.subtle.encrypt(
      { name: "AES-GCM", iv: new Uint8Array(16) },
      await stretch(newPassword, Buffer.from(salt, "hex")),
      Uint8Array.from(Buffer.from(entropy, "hex"))
    )
  );

  return encode("en", toWords(bytes), 180);
};