import { NitroModules } from 'react-native-nitro-modules';

import type { MlKemKeyPair } from './specs/v1/mlKemKeyPair.nitro';

import {

  CryptoKey,

  KeyObject,

  PublicKeyObject,

  PrivateKeyObject,

  isCryptoKey,

} from './keys';

import type {

  CryptoKeyPair,

  KeyUsage,

  SubtleAlgorithm,

  EncapsulateResult,

  BinaryLike,

} from './utils';

import {

  hasAnyNotIn,

  lazyDOMException,

  getUsagesUnion,

  KFormatType,

  KeyEncoding,

  isStringOrBuffer,

  binaryLikeToArrayBuffer as toAB,

} from './utils';



export type MlKemVariant = 'ML-KEM-512' | 'ML-KEM-768' | 'ML-KEM-1024';



type MlKemKeyType = 'ml-kem-512' | 'ml-kem-768' | 'ml-kem-1024';



type KeyInput = BinaryLike | KeyObject | CryptoKey | KeyInputObject;



export interface KeyInputObject {

  key: BinaryLike | KeyObject | CryptoKey;

  format?: 'pem' | 'der';

  type?: 'pkcs1' | 'pkcs8' | 'spki' | 'sec1';

}



const ML_KEM_VARIANTS: Record<MlKemKeyType, MlKemVariant> = {

  'ml-kem-512': 'ML-KEM-512',

  'ml-kem-768': 'ML-KEM-768',

  'ml-kem-1024': 'ML-KEM-1024',

};



function isMlKemKeyType(type: string): type is MlKemKeyType {

  return type in ML_KEM_VARIANTS;

}



function unpackEncapsulateResult(packed: ArrayBuffer): EncapsulateResult {

  const view = new DataView(packed);

  const ciphertextLen = view.getUint32(0, true);

  const sharedKeyLen = view.getUint32(4, true);

  const headerSize = 8;

  const ciphertext = packed.slice(headerSize, headerSize + ciphertextLen);

  const sharedKey = packed.slice(

    headerSize + ciphertextLen,

    headerSize + ciphertextLen + sharedKeyLen,

  );

  return { ciphertext, sharedKey };

}



export class MlKem {

  variant: MlKemVariant;

  native: MlKemKeyPair;



  constructor(variant: MlKemVariant) {

    this.variant = variant;

    this.native = NitroModules.createHybridObject<MlKemKeyPair>('MlKemKeyPair');

    this.native.setVariant(variant);

  }



  async generateKeyPair(): Promise<void> {

    await this.native.generateKeyPair(

      KFormatType.DER,

      KeyEncoding.SPKI,

      KFormatType.DER,

      KeyEncoding.PKCS8,

    );

  }



  generateKeyPairSync(): void {

    this.native.generateKeyPairSync(

      KFormatType.DER,

      KeyEncoding.SPKI,

      KFormatType.DER,

      KeyEncoding.PKCS8,

    );

  }



  getPublicKey(): ArrayBuffer {

    return this.native.getPublicKey();

  }



  getPrivateKey(): ArrayBuffer {

    return this.native.getPrivateKey();

  }



  setPublicKey(keyData: ArrayBuffer, format: number, type: number): void {

    this.native.setPublicKey(keyData, format, type);

  }



  setPrivateKey(keyData: ArrayBuffer, format: number, type: number): void {

    this.native.setPrivateKey(keyData, format, type);

  }



  async encapsulate(): Promise<EncapsulateResult> {

    const packed = await this.native.encapsulate();

    return unpackEncapsulateResult(packed);

  }



  encapsulateSync(): EncapsulateResult {

    const packed = this.native.encapsulateSync();

    return unpackEncapsulateResult(packed);

  }



  async decapsulate(ciphertext: ArrayBuffer): Promise<ArrayBuffer> {

    return this.native.decapsulate(ciphertext);

  }



  decapsulateSync(ciphertext: ArrayBuffer): ArrayBuffer {

    return this.native.decapsulateSync(ciphertext);

  }

}



function prepareKey(

  key: KeyInput,

  isPublic: boolean,

): { keyObject: KeyObject } {

  if (key instanceof KeyObject) {

    if (isPublic) {

      if (key.type === 'secret') {

        throw new Error('Cannot use secret key for encapsulation');

      }

    } else {

      if (key.type !== 'private') {

        throw new Error('Key must be a private key for decapsulation');

      }

    }

    return { keyObject: key };

  }



  if (isCryptoKey(key)) {

    const cryptoKey = key as CryptoKey;

    return prepareKey(cryptoKey.keyObject, isPublic);

  }



  if (isStringOrBuffer(key)) {

    const isPem = typeof key === 'string' && key.includes('-----BEGIN');

    const format = isPem ? KFormatType.PEM : undefined;

    const keyType = isPublic ? 'public' : 'private';

    const keyData = toAB(key);

    const keyObject = KeyObject.createKeyObject(keyType, keyData, format);

    return { keyObject };

  }



  if (typeof key === 'object' && 'key' in key) {

    const keyObj = key as KeyInputObject;

    const { key: data, format, type } = keyObj;



    if (data instanceof KeyObject) {

      return { keyObject: data };

    }



    if (isCryptoKey(data)) {

      return { keyObject: (data as CryptoKey).keyObject };

    }



    if (!isStringOrBuffer(data)) {

      throw new Error('Invalid key data type');

    }



    const isPem =

      format === 'pem' ||

      (typeof data === 'string' && data.includes('-----BEGIN'));

    const kFormat = isPem

      ? KFormatType.PEM

      : format === 'der'

        ? KFormatType.DER

        : undefined;



    let kType: KeyEncoding | undefined;

    if (type === 'pkcs8') kType = KeyEncoding.PKCS8;

    else if (type === 'pkcs1') kType = KeyEncoding.PKCS1;

    else if (type === 'sec1') kType = KeyEncoding.SEC1;

    else if (type === 'spki') kType = KeyEncoding.SPKI;



    const keyType = isPublic ? 'public' : 'private';

    const keyData = toAB(data);

    const keyObject = KeyObject.createKeyObject(

      keyType,

      keyData,

      kFormat,

      kType,

    );

    return { keyObject };

  }



  throw new Error('Invalid key input');

}



function getVariantFromKey(keyObject: KeyObject): MlKemVariant {

  const keyType = keyObject.handle.getAsymmetricKeyType();

  if (!isMlKemKeyType(keyType)) {

    throw new Error(

      `Key is not an ML-KEM key. Got asymmetricKeyType: ${keyType}`,

    );

  }

  return ML_KEM_VARIANTS[keyType];

}



export function encapsulate(

  key: KeyInput,

  callback?: (err: Error | null, result?: EncapsulateResult) => void,

): EncapsulateResult | void {

  const doEncapsulate = (): EncapsulateResult => {

    if (key === null || key === undefined) {

      throw new Error('Public key is required for encapsulation');

    }



    const { keyObject } = prepareKey(key, true);

    const variant = getVariantFromKey(keyObject);

    const mlkem = new MlKem(variant);



    const keyData = keyObject.handle.exportKey(

      KFormatType.DER,

      KeyEncoding.SPKI,

    );

    mlkem.setPublicKey(keyData, KFormatType.DER, KeyEncoding.SPKI);



    return mlkem.encapsulateSync();

  };



  if (callback) {

    try {

      const result = doEncapsulate();

      process.nextTick(callback, null, result);

    } catch (err) {

      process.nextTick(callback, err as Error);

    }

    return;

  }



  return doEncapsulate();

}



export function decapsulate(

  key: KeyInput,

  ciphertext: BinaryLike,

  callback?: (err: Error | null, result?: ArrayBuffer) => void,

): ArrayBuffer | void {

  const doDecapsulate = (): ArrayBuffer => {

    if (key === null || key === undefined) {

      throw new Error('Private key is required for decapsulation');

    }



    const { keyObject } = prepareKey(key, false);

    const variant = getVariantFromKey(keyObject);

    const mlkem = new MlKem(variant);



    const keyData = keyObject.handle.exportKey(

      KFormatType.DER,

      KeyEncoding.PKCS8,

    );

    mlkem.setPrivateKey(keyData, KFormatType.DER, KeyEncoding.PKCS8);



    const ciphertextBuffer = toAB(ciphertext) as ArrayBuffer;

    return mlkem.decapsulateSync(ciphertextBuffer);

  };



  if (callback) {

    try {

      const result = doDecapsulate();

      process.nextTick(callback, null, result);

    } catch (err) {

      process.nextTick(callback, err as Error);

    }

    return;

  }



  return doDecapsulate();

}



export async function mlkem_generateKeyPairWebCrypto(

  variant: MlKemVariant,

  extractable: boolean,

  keyUsages: KeyUsage[],

): Promise<CryptoKeyPair> {

  if (

    hasAnyNotIn(keyUsages, [

      'encapsulateBits',

      'encapsulateKey',

      'decapsulateBits',

      'decapsulateKey',

    ])

  ) {

    throw lazyDOMException(

      `Unsupported key usage for ${variant}`,

      'SyntaxError',

    );

  }



  const publicUsages = getUsagesUnion(

    keyUsages,

    'encapsulateBits',

    'encapsulateKey',

  );

  const privateUsages = getUsagesUnion(

    keyUsages,

    'decapsulateBits',

    'decapsulateKey',

  );



  if (privateUsages.length === 0) {

    throw lazyDOMException('Usages cannot be empty', 'SyntaxError');

  }



  const mlkem = new MlKem(variant);

  await mlkem.generateKeyPair();



  const publicKeyData = mlkem.getPublicKey();

  const privateKeyData = mlkem.getPrivateKey();



  const pub = KeyObject.createKeyObject(

    'public',

    publicKeyData,

    KFormatType.DER,

    KeyEncoding.SPKI,

  ) as PublicKeyObject;

  const publicKey = new CryptoKey(

    pub,

    { name: variant } as SubtleAlgorithm,

    publicUsages,

    true,

  );



  const priv = KeyObject.createKeyObject(

    'private',

    privateKeyData,

    KFormatType.DER,

    KeyEncoding.PKCS8,

  ) as PrivateKeyObject;

  const privateKey = new CryptoKey(

    priv,

    { name: variant } as SubtleAlgorithm,

    privateUsages,

    extractable,

  );



  return { publicKey, privateKey };

}