// @ts-check
// Import the types from the TypeScript file
/**
 * @typedef {import('../dc-types').GetProtocol} GetProtocol
 * @typedef {import('../dc-types').DigitalCredentialGetRequest} DigitalCredentialGetRequest
 * @typedef {import('../dc-types').CredentialRequestOptions} CredentialRequestOptions
 * @typedef {import('../dc-types').CreateProtocol} CreateProtocol
 * @typedef {import('../dc-types').DigitalCredentialCreateRequest} DigitalCredentialCreateRequest
 * @typedef {import('../dc-types').CredentialCreationOptions} CredentialCreationOptions
 * @typedef {import('../dc-types').SendMessageData} SendMessageData
 * @typedef {import('../dc-types').MakeGetOptionsConfig} MakeGetOptionsConfig
 * @typedef {import('../dc-types').MakeCreateOptionsConfig} MakeCreateOptionsConfig
 * @typedef {import('../dc-types').CredentialMediationRequirement} CredentialMediationRequirement
 * @typedef {import('../dc-types').MobileDocumentRequest} MobileDocumentRequest
 * @typedef {GetProtocol | CreateProtocol} Protocol
 */

/** @type {Record<Protocol, object | MobileDocumentRequest>} */
const CANONICAL_REQUEST_OBJECTS = {
  openid4vci: {
    /* Canonical object coming soon */
  },
  "openid4vp-v1-unsigned": {
    /* Canonical object coming soon */
  },
  "openid4vp-v1-signed": {
    /* Canonical object coming soon */
  },
  "openid4vp-v1-multisigned": {
    /* Canonical object coming soon */
  },
  /** @type MobileDocumentRequest **/
  "org-iso-mdoc": {
    deviceRequest:
      "omd2ZXJzaW9uYzEuMGtkb2NSZXF1ZXN0c4GhbGl0ZW1zUmVxdWVzdNgYWIKiZ2RvY1R5cGV1b3JnLmlzby4xODAxMy41LjEubURMam5hbWVTcGFjZXOhcW9yZy5pc28uMTgwMTMuNS4x9pWthZ2Vfb3Zlcl8yMfRqZ2l2ZW5fbmFtZfRrZmFtaWx5X25hbWX0cmRyaXZpbmdfcHJpdmlsZWdlc_RocG9ydHJhaXT0",
    encryptionInfo:
      "gmVkY2FwaaJlbm9uY2VYICBetSsDkKlE_G9JSIHwPzr3ctt6Ol9GgmCH8iGdGQNJcnJlY2lwaWVudFB1YmxpY0tleaQBAiABIVggKKm1iPeuOb9bDJeeJEL4QldYlWvY7F_K8eZkmYdS9PwiWCCm9PLEmosiE_ildsE11lqq4kDkjhfQUKPpbX-Hm1ZSLg",
  },
};

/**
 * Internal helper to create final options from a list of requests.
 *
 * @template {DigitalCredentialGetRequest[] | DigitalCredentialCreateRequest[]} TRequests
 * @template {CredentialRequestOptions | CredentialCreationOptions} TOptions
 * @param {TRequests} requests
 * @param {CredentialMediationRequirement} [mediation]
 * @param {AbortSignal} [signal]
 * @returns {TOptions}
 */
function makeOptionsFromRequests(requests, mediation, signal) {
  /** @type {TOptions} */
  const options = /** @type {TOptions} */ ({ digital: { requests } });

  if (mediation) {
    options.mediation = mediation;
  }

  if (signal) {
    options.signal = signal;
  }

  return options;
}

/**
 * Build requests from protocols, using canonical data for each protocol.
 * For create operations with explicit data, uses that data for all protocols.
 *
 * @template Req
 * @param {Protocol[]} protocols
 * @param {Record<string, (data?: MobileDocumentRequest | object) => Req>} mapping
 * @param {MobileDocumentRequest | object} [explicitData] - Explicit data for create operations
 * @returns {Req[]}
 * @throws {Error} If an unknown protocol string is encountered.
 */
function buildRequestsFromProtocols(protocols, mapping, explicitData) {
  return protocols.map((protocol) => {
    if (!(protocol in mapping)) {
      throw new Error(`Unknown request type within array: ${protocol}`);
    }
    // Use explicit data if provided (for create with data), otherwise canonical data
    return mapping[protocol](explicitData);
  });
}

/** @type {{
 *   get: Record<GetProtocol, (data?: MobileDocumentRequest | object) => DigitalCredentialGetRequest>;
 *   create: Record<CreateProtocol, (data?: object) => DigitalCredentialCreateRequest>;
 * }} */
const allMappings = {
  get: {
    "org-iso-mdoc": (
      data = { ...CANONICAL_REQUEST_OBJECTS["org-iso-mdoc"] },
    ) => {
      return { protocol: "org-iso-mdoc", data };
    },
    "openid4vp-v1-unsigned": (
      data = { ...CANONICAL_REQUEST_OBJECTS["openid4vp-v1-unsigned"] },
    ) => {
      return { protocol: "openid4vp-v1-unsigned", data };
    },
    "openid4vp-v1-signed": (
      data = { ...CANONICAL_REQUEST_OBJECTS["openid4vp-v1-signed"] },
    ) => {
      return { protocol: "openid4vp-v1-signed", data };
    },
    "openid4vp-v1-multisigned": (
      data = { ...CANONICAL_REQUEST_OBJECTS["openid4vp-v1-multisigned"] },
    ) => {
      return { protocol: "openid4vp-v1-multisigned", data };
    },
  },
  create: {
    "openid4vci": (data = { ...CANONICAL_REQUEST_OBJECTS["openid4vci"] }) => {
      return { protocol: "openid4vci", data };
    },
  },
};

/**
 * Generic helper to create credential options from config with protocol already set.
 * @template {MakeGetOptionsConfig | MakeCreateOptionsConfig} TConfig
 * @template {DigitalCredentialGetRequest | DigitalCredentialCreateRequest} TRequest
 * @template {CredentialRequestOptions | CredentialCreationOptions} TOptions
 * @param {TConfig} config - Configuration options with protocol already defaulted
 * @param {Record<string, (data?: MobileDocumentRequest | object) => TRequest>} mapping - Protocol to request mapping
 * @returns {TOptions}
 */
function makeCredentialOptionsFromConfig(config, mapping) {
  const { protocol, requests = [], data, mediation, signal } = config;

  // Validate that we have either a protocol or requests
  if (!protocol && !requests?.length) {
    throw new Error("No protocol. Can't make options.");
  }

  /** @type {TRequest[]} */
  const  allRequests = [];

  allRequests.push(.../** @type {TRequest[]} */ (requests));

  if (protocol) {
    const protocolArray = Array.isArray(protocol) ? protocol : [protocol];
    const protocolRequests = buildRequestsFromProtocols(protocolArray, mapping, data);
    allRequests.push(...protocolRequests);
  }

  return /** @type {TOptions} */ (makeOptionsFromRequests(allRequests, mediation, signal));
}

/**
 * Creates options for getting credentials.
 * @export
 * @param {MakeGetOptionsConfig} [config={}] - Configuration options
 * @returns {CredentialRequestOptions}
 */
export function makeGetOptions(config = {}) {
  /** @type {MakeGetOptionsConfig} */
  const configWithDefaults = {
    protocol: ["openid4vp-v1-unsigned", "org-iso-mdoc"],
    ...config,
  };

  return /** @type {CredentialRequestOptions} */ (
    makeCredentialOptionsFromConfig(configWithDefaults, allMappings.get)
  );
}

/**
 * Creates options for creating credentials.
 * @export
 * @param {MakeCreateOptionsConfig} [config={}] - Configuration options
 * @returns {CredentialCreationOptions}
 */
export function makeCreateOptions(config = {}) {
  /** @type {MakeCreateOptionsConfig} */
  const configWithDefaults = {
    protocol: "openid4vci",
    ...config,
  };

  return /** @type {CredentialCreationOptions} */ (
    makeCredentialOptionsFromConfig(configWithDefaults, allMappings.create)
  );
}

/**
 * Sends a message to an iframe and return the response.
 *
 * @param {HTMLIFrameElement} iframe - The iframe element to send the message to.
 * @param {SendMessageData} data - The data to be sent to the iframe.
 * @returns {Promise<any>} - A promise that resolves with the response from the iframe.
 */
export function sendMessage(iframe, data) {
  return new Promise((resolve, reject) => {
    if (!iframe.contentWindow) {
      reject(
        new Error(
          "iframe.contentWindow is undefined, cannot send message (something is wrong with the test that called this).",
        ),
      );
      return;
    }
    window.addEventListener("message", function messageListener(event) {
      if (event.source === iframe.contentWindow) {
        window.removeEventListener("message", messageListener);
        resolve(event.data);
      }
    });
    iframe.contentWindow.postMessage(data, "*");
  });
}

/**
 * Load an iframe with the specified URL and wait for it to load.
 *
 * @param {HTMLIFrameElement} iframe
 * @param {string|URL} url
 * @returns {Promise<void>}
 */
export function loadIframe(iframe, url) {
  return new Promise((resolve, reject) => {
    iframe.addEventListener("load", () => resolve(), { once: true });
    iframe.addEventListener("error", (event) => reject(event.error), {
      once: true,
    });
    if (!iframe.isConnected) {
      document.body.appendChild(iframe);
    }
    iframe.src = url.toString();
  });
}