/* eslint-disable import/export */
/* eslint-disable complexity */
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
/* eslint-disable @typescript-eslint/no-empty-interface */

import {
  encodeMessage,
  decodeMessage,
  message,
  enumeration,
} from "protons-runtime";
import type { Codec } from "protons-runtime";
import type { Uint8ArrayList } from "uint8arraylist";

export interface Index {
  digest: Uint8Array;
  receiverTime: bigint;
  senderTime: bigint;
  pubsubTopic: string;
}

export namespace Index {
  let _codec: Codec<Index>;

  export const codec = (): Codec<Index> => {
    if (_codec == null) {
      _codec = message<Index>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.digest != null && obj.digest.byteLength > 0) {
            w.uint32(10);
            w.bytes(obj.digest);
          }

          if (obj.receiverTime != null && obj.receiverTime !== 0n) {
            w.uint32(16);
            w.sint64(obj.receiverTime);
          }

          if (obj.senderTime != null && obj.senderTime !== 0n) {
            w.uint32(24);
            w.sint64(obj.senderTime);
          }

          if (obj.pubsubTopic != null && obj.pubsubTopic !== "") {
            w.uint32(34);
            w.string(obj.pubsubTopic);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            digest: new Uint8Array(0),
            receiverTime: 0n,
            senderTime: 0n,
            pubsubTopic: "",
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.digest = reader.bytes();
                break;
              case 2:
                obj.receiverTime = reader.sint64();
                break;
              case 3:
                obj.senderTime = reader.sint64();
                break;
              case 4:
                obj.pubsubTopic = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<Index>): Uint8Array => {
    return encodeMessage(obj, Index.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): Index => {
    return decodeMessage(buf, Index.codec());
  };
}

export interface PagingInfo {
  pageSize?: bigint;
  cursor?: Index;
  direction?: PagingInfo.Direction;
}

export namespace PagingInfo {
  export enum Direction {
    BACKWARD = "BACKWARD",
    FORWARD = "FORWARD",
  }

  enum __DirectionValues {
    BACKWARD = 0,
    FORWARD = 1,
  }

  export namespace Direction {
    export const codec = (): Codec<Direction> => {
      return enumeration<Direction>(__DirectionValues);
    };
  }

  let _codec: Codec<PagingInfo>;

  export const codec = (): Codec<PagingInfo> => {
    if (_codec == null) {
      _codec = message<PagingInfo>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.pageSize != null) {
            w.uint32(8);
            w.uint64(obj.pageSize);
          }

          if (obj.cursor != null) {
            w.uint32(18);
            Index.codec().encode(obj.cursor, w);
          }

          if (obj.direction != null) {
            w.uint32(24);
            PagingInfo.Direction.codec().encode(obj.direction, w);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {};

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.pageSize = reader.uint64();
                break;
              case 2:
                obj.cursor = Index.codec().decode(reader, reader.uint32());
                break;
              case 3:
                obj.direction = PagingInfo.Direction.codec().decode(reader);
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<PagingInfo>): Uint8Array => {
    return encodeMessage(obj, PagingInfo.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): PagingInfo => {
    return decodeMessage(buf, PagingInfo.codec());
  };
}

export interface ContentFilter {
  contentTopic: string;
}

export namespace ContentFilter {
  let _codec: Codec<ContentFilter>;

  export const codec = (): Codec<ContentFilter> => {
    if (_codec == null) {
      _codec = message<ContentFilter>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.contentTopic != null && obj.contentTopic !== "") {
            w.uint32(10);
            w.string(obj.contentTopic);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            contentTopic: "",
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.contentTopic = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<ContentFilter>): Uint8Array => {
    return encodeMessage(obj, ContentFilter.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): ContentFilter => {
    return decodeMessage(buf, ContentFilter.codec());
  };
}

export interface HistoryQuery {
  pubsubTopic?: string;
  contentFilters: ContentFilter[];
  pagingInfo?: PagingInfo;
  startTime?: bigint;
  endTime?: bigint;
}

export namespace HistoryQuery {
  let _codec: Codec<HistoryQuery>;

  export const codec = (): Codec<HistoryQuery> => {
    if (_codec == null) {
      _codec = message<HistoryQuery>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.pubsubTopic != null) {
            w.uint32(18);
            w.string(obj.pubsubTopic);
          }

          if (obj.contentFilters != null) {
            for (const value of obj.contentFilters) {
              w.uint32(26);
              ContentFilter.codec().encode(value, w);
            }
          }

          if (obj.pagingInfo != null) {
            w.uint32(34);
            PagingInfo.codec().encode(obj.pagingInfo, w);
          }

          if (obj.startTime != null) {
            w.uint32(40);
            w.sint64(obj.startTime);
          }

          if (obj.endTime != null) {
            w.uint32(48);
            w.sint64(obj.endTime);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            contentFilters: [],
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 2:
                obj.pubsubTopic = reader.string();
                break;
              case 3:
                obj.contentFilters.push(
                  ContentFilter.codec().decode(reader, reader.uint32()),
                );
                break;
              case 4:
                obj.pagingInfo = PagingInfo.codec().decode(
                  reader,
                  reader.uint32(),
                );
                break;
              case 5:
                obj.startTime = reader.sint64();
                break;
              case 6:
                obj.endTime = reader.sint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<HistoryQuery>): Uint8Array => {
    return encodeMessage(obj, HistoryQuery.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): HistoryQuery => {
    return decodeMessage(buf, HistoryQuery.codec());
  };
}

export interface HistoryResponse {
  messages: WakuMessage[];
  pagingInfo?: PagingInfo;
  error: HistoryResponse.HistoryError;
}

export namespace HistoryResponse {
  export enum HistoryError {
    NONE = "NONE",
    INVALID_CURSOR = "INVALID_CURSOR",
  }

  enum __HistoryErrorValues {
    NONE = 0,
    INVALID_CURSOR = 1,
  }

  export namespace HistoryError {
    export const codec = (): Codec<HistoryError> => {
      return enumeration<HistoryError>(__HistoryErrorValues);
    };
  }

  let _codec: Codec<HistoryResponse>;

  export const codec = (): Codec<HistoryResponse> => {
    if (_codec == null) {
      _codec = message<HistoryResponse>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.messages != null) {
            for (const value of obj.messages) {
              w.uint32(18);
              WakuMessage.codec().encode(value, w);
            }
          }

          if (obj.pagingInfo != null) {
            w.uint32(26);
            PagingInfo.codec().encode(obj.pagingInfo, w);
          }

          if (obj.error != null && __HistoryErrorValues[obj.error] !== 0) {
            w.uint32(32);
            HistoryResponse.HistoryError.codec().encode(obj.error, w);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            messages: [],
            error: HistoryError.NONE,
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 2:
                obj.messages.push(
                  WakuMessage.codec().decode(reader, reader.uint32()),
                );
                break;
              case 3:
                obj.pagingInfo = PagingInfo.codec().decode(
                  reader,
                  reader.uint32(),
                );
                break;
              case 4:
                obj.error = HistoryResponse.HistoryError.codec().decode(reader);
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<HistoryResponse>): Uint8Array => {
    return encodeMessage(obj, HistoryResponse.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): HistoryResponse => {
    return decodeMessage(buf, HistoryResponse.codec());
  };
}

export interface HistoryRpc {
  requestId: string;
  query?: HistoryQuery;
  response?: HistoryResponse;
}

export namespace HistoryRpc {
  let _codec: Codec<HistoryRpc>;

  export const codec = (): Codec<HistoryRpc> => {
    if (_codec == null) {
      _codec = message<HistoryRpc>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.requestId != null && obj.requestId !== "") {
            w.uint32(10);
            w.string(obj.requestId);
          }

          if (obj.query != null) {
            w.uint32(18);
            HistoryQuery.codec().encode(obj.query, w);
          }

          if (obj.response != null) {
            w.uint32(26);
            HistoryResponse.codec().encode(obj.response, w);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            requestId: "",
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.requestId = reader.string();
                break;
              case 2:
                obj.query = HistoryQuery.codec().decode(
                  reader,
                  reader.uint32(),
                );
                break;
              case 3:
                obj.response = HistoryResponse.codec().decode(
                  reader,
                  reader.uint32(),
                );
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<HistoryRpc>): Uint8Array => {
    return encodeMessage(obj, HistoryRpc.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): HistoryRpc => {
    return decodeMessage(buf, HistoryRpc.codec());
  };
}

export interface RateLimitProof {
  proof: Uint8Array;
  merkleRoot: Uint8Array;
  epoch: Uint8Array;
  shareX: Uint8Array;
  shareY: Uint8Array;
  nullifier: Uint8Array;
  rlnIdentifier: Uint8Array;
}

export namespace RateLimitProof {
  let _codec: Codec<RateLimitProof>;

  export const codec = (): Codec<RateLimitProof> => {
    if (_codec == null) {
      _codec = message<RateLimitProof>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.proof != null && obj.proof.byteLength > 0) {
            w.uint32(10);
            w.bytes(obj.proof);
          }

          if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
            w.uint32(18);
            w.bytes(obj.merkleRoot);
          }

          if (obj.epoch != null && obj.epoch.byteLength > 0) {
            w.uint32(26);
            w.bytes(obj.epoch);
          }

          if (obj.shareX != null && obj.shareX.byteLength > 0) {
            w.uint32(34);
            w.bytes(obj.shareX);
          }

          if (obj.shareY != null && obj.shareY.byteLength > 0) {
            w.uint32(42);
            w.bytes(obj.shareY);
          }

          if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
            w.uint32(50);
            w.bytes(obj.nullifier);
          }

          if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
            w.uint32(58);
            w.bytes(obj.rlnIdentifier);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            proof: new Uint8Array(0),
            merkleRoot: new Uint8Array(0),
            epoch: new Uint8Array(0),
            shareX: new Uint8Array(0),
            shareY: new Uint8Array(0),
            nullifier: new Uint8Array(0),
            rlnIdentifier: new Uint8Array(0),
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.proof = reader.bytes();
                break;
              case 2:
                obj.merkleRoot = reader.bytes();
                break;
              case 3:
                obj.epoch = reader.bytes();
                break;
              case 4:
                obj.shareX = reader.bytes();
                break;
              case 5:
                obj.shareY = reader.bytes();
                break;
              case 6:
                obj.nullifier = reader.bytes();
                break;
              case 7:
                obj.rlnIdentifier = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<RateLimitProof>): Uint8Array => {
    return encodeMessage(obj, RateLimitProof.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): RateLimitProof => {
    return decodeMessage(buf, RateLimitProof.codec());
  };
}

export interface WakuMessage {
  payload: Uint8Array;
  contentTopic: string;
  version?: number;
  timestamp?: bigint;
  meta?: Uint8Array;
  rateLimitProof?: RateLimitProof;
  ephemeral?: boolean;
}

export namespace WakuMessage {
  let _codec: Codec<WakuMessage>;

  export const codec = (): Codec<WakuMessage> => {
    if (_codec == null) {
      _codec = message<WakuMessage>(
        (obj, w, opts = {}) => {
          if (opts.lengthDelimited !== false) {
            w.fork();
          }

          if (obj.payload != null && obj.payload.byteLength > 0) {
            w.uint32(10);
            w.bytes(obj.payload);
          }

          if (obj.contentTopic != null && obj.contentTopic !== "") {
            w.uint32(18);
            w.string(obj.contentTopic);
          }

          if (obj.version != null) {
            w.uint32(24);
            w.uint32(obj.version);
          }

          if (obj.timestamp != null) {
            w.uint32(80);
            w.sint64(obj.timestamp);
          }

          if (obj.meta != null) {
            w.uint32(90);
            w.bytes(obj.meta);
          }

          if (obj.rateLimitProof != null) {
            w.uint32(170);
            RateLimitProof.codec().encode(obj.rateLimitProof, w);
          }

          if (obj.ephemeral != null) {
            w.uint32(248);
            w.bool(obj.ephemeral);
          }

          if (opts.lengthDelimited !== false) {
            w.ldelim();
          }
        },
        (reader, length) => {
          const obj: any = {
            payload: new Uint8Array(0),
            contentTopic: "",
          };

          const end = length == null ? reader.len : reader.pos + length;

          while (reader.pos < end) {
            const tag = reader.uint32();

            switch (tag >>> 3) {
              case 1:
                obj.payload = reader.bytes();
                break;
              case 2:
                obj.contentTopic = reader.string();
                break;
              case 3:
                obj.version = reader.uint32();
                break;
              case 10:
                obj.timestamp = reader.sint64();
                break;
              case 11:
                obj.meta = reader.bytes();
                break;
              case 21:
                obj.rateLimitProof = RateLimitProof.codec().decode(
                  reader,
                  reader.uint32(),
                );
                break;
              case 31:
                obj.ephemeral = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }

          return obj;
        },
      );
    }

    return _codec;
  };

  export const encode = (obj: Partial<WakuMessage>): Uint8Array => {
    return encodeMessage(obj, WakuMessage.codec());
  };

  export const decode = (buf: Uint8Array | Uint8ArrayList): WakuMessage => {
    return decodeMessage(buf, WakuMessage.codec());
  };
}