import * as protobuf from "protobufjs/light";

export interface PublicKeyMessagePayload {
  encryptionPublicKey: Uint8Array;
  ethAddress: Uint8Array;
  signature: Uint8Array;
}

const Root = protobuf.Root,
  Type = protobuf.Type,
  Field = protobuf.Field;

/**
 * Message used to communicate the encryption public key linked to a given Ethereum account
 */
export class PublicKeyMessage {
  private static Type = new Type("PublicKeyMessage")
    .add(new Field("encryptionPublicKey", 1, "bytes"))
    .add(new Field("ethAddress", 2, "bytes"))
    .add(new Field("signature", 3, "bytes"));
  private static Root = new Root()
    .define("messages")
    .add(PublicKeyMessage.Type);

  constructor(public payload: PublicKeyMessagePayload) {}

  public encode(): Uint8Array {
    const message = PublicKeyMessage.Type.create(this.payload);
    return PublicKeyMessage.Type.encode(message).finish();
  }

  public static decode(bytes: Uint8Array): PublicKeyMessage | undefined {
    const payload = PublicKeyMessage.Type.decode(
      bytes
    ) as unknown as PublicKeyMessagePayload;
    if (
      !payload.signature ||
      !payload.encryptionPublicKey ||
      !payload.ethAddress
    ) {
      console.log("Field missing on decoded Public Key Message", payload);
      return;
    }
    return new PublicKeyMessage(payload);
  }

  get encryptionPublicKey(): Uint8Array {
    return this.payload.encryptionPublicKey;
  }

  get ethAddress(): Uint8Array {
    return this.payload.ethAddress;
  }

  get signature(): Uint8Array {
    return this.payload.signature;
  }
}

export interface PrivateMessagePayload {
  toAddress: Uint8Array;
  message: string;
}

/**
 * Encrypted Message used for private communication over the Waku network.
 */
export class PrivateMessage {
  private static Type = new Type("PrivateMessage")
    .add(new Field("toAddress", 1, "bytes"))
    .add(new Field("message", 2, "string"));
  private static Root = new Root().define("messages").add(PrivateMessage.Type);

  constructor(public payload: PrivateMessagePayload) {}

  public encode(): Uint8Array {
    const message = PrivateMessage.Type.create(this.payload);
    return PrivateMessage.Type.encode(message).finish();
  }

  public static decode(bytes: Uint8Array): PrivateMessage | undefined {
    const payload = PrivateMessage.Type.decode(
      bytes
    ) as unknown as PrivateMessagePayload;
    if (!payload.toAddress || !payload.message) {
      console.log("Field missing on decoded Private Message", payload);
      return;
    }
    return new PrivateMessage(payload);
  }

  get toAddress(): Uint8Array {
    return this.payload.toAddress;
  }

  get message(): string {
    return this.payload.message;
  }
}