/* eslint-disable */
import * as _m0 from "protobufjs/minimal";
import { GoodbyeReason, goodbyeReasonFromJSON, goodbyeReasonToJSON } from "./goodbye_reason";
import { State, stateFromJSON, stateToJSON } from "./state";

export const protobufPackage = "protocol.message_c2s";

export interface MessageC2SHello {
  /** Version of the protocol. Currently always 1 */
  version: number;
  /** The username that the client is requesting. */
  requestedUsername: string;
  /** The state the connection will go into after the handshake. */
  nextState: State;
}

export enum MessageC2SHello_packetInfo {
  unknown = 0,
  type = 1,
  UNRECOGNIZED = -1,
}

export function messageC2SHello_packetInfoFromJSON(object: any): MessageC2SHello_packetInfo {
  switch (object) {
    case 0:
    case "unknown":
      return MessageC2SHello_packetInfo.unknown;
    case 1:
    case "type":
      return MessageC2SHello_packetInfo.type;
    case -1:
    case "UNRECOGNIZED":
    default:
      return MessageC2SHello_packetInfo.UNRECOGNIZED;
  }
}

export function messageC2SHello_packetInfoToJSON(object: MessageC2SHello_packetInfo): string {
  switch (object) {
    case MessageC2SHello_packetInfo.unknown:
      return "unknown";
    case MessageC2SHello_packetInfo.type:
      return "type";
    case MessageC2SHello_packetInfo.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface MessageC2SGoodbye {
  /** The reason the client is disconnecting the server */
  reason: GoodbyeReason;
}

export enum MessageC2SGoodbye_packetInfo {
  unknown = 0,
  type = 2,
  UNRECOGNIZED = -1,
}

export function messageC2SGoodbye_packetInfoFromJSON(object: any): MessageC2SGoodbye_packetInfo {
  switch (object) {
    case 0:
    case "unknown":
      return MessageC2SGoodbye_packetInfo.unknown;
    case 2:
    case "type":
      return MessageC2SGoodbye_packetInfo.type;
    case -1:
    case "UNRECOGNIZED":
    default:
      return MessageC2SGoodbye_packetInfo.UNRECOGNIZED;
  }
}

export function messageC2SGoodbye_packetInfoToJSON(object: MessageC2SGoodbye_packetInfo): string {
  switch (object) {
    case MessageC2SGoodbye_packetInfo.unknown:
      return "unknown";
    case MessageC2SGoodbye_packetInfo.type:
      return "type";
    case MessageC2SGoodbye_packetInfo.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface MessageC2SChat {
  /** The chat message to sent */
  message: string;
}

export enum MessageC2SChat_packetInfo {
  unknown = 0,
  type = 3,
  UNRECOGNIZED = -1,
}

export function messageC2SChat_packetInfoFromJSON(object: any): MessageC2SChat_packetInfo {
  switch (object) {
    case 0:
    case "unknown":
      return MessageC2SChat_packetInfo.unknown;
    case 3:
    case "type":
      return MessageC2SChat_packetInfo.type;
    case -1:
    case "UNRECOGNIZED":
    default:
      return MessageC2SChat_packetInfo.UNRECOGNIZED;
  }
}

export function messageC2SChat_packetInfoToJSON(object: MessageC2SChat_packetInfo): string {
  switch (object) {
    case MessageC2SChat_packetInfo.unknown:
      return "unknown";
    case MessageC2SChat_packetInfo.type:
      return "type";
    case MessageC2SChat_packetInfo.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface MessageC2SPing {
}

export enum MessageC2SPing_packetInfo {
  unknown = 0,
  type = 4,
  UNRECOGNIZED = -1,
}

export function messageC2SPing_packetInfoFromJSON(object: any): MessageC2SPing_packetInfo {
  switch (object) {
    case 0:
    case "unknown":
      return MessageC2SPing_packetInfo.unknown;
    case 4:
    case "type":
      return MessageC2SPing_packetInfo.type;
    case -1:
    case "UNRECOGNIZED":
    default:
      return MessageC2SPing_packetInfo.UNRECOGNIZED;
  }
}

export function messageC2SPing_packetInfoToJSON(object: MessageC2SPing_packetInfo): string {
  switch (object) {
    case MessageC2SPing_packetInfo.unknown:
      return "unknown";
    case MessageC2SPing_packetInfo.type:
      return "type";
    case MessageC2SPing_packetInfo.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface MessageC2SInput {
  upPressed: boolean;
  downPressed: boolean;
  leftPressed: boolean;
  rightPressed: boolean;
}

export enum MessageC2SInput_packetInfo {
  unknown = 0,
  type = 11,
  UNRECOGNIZED = -1,
}

export function messageC2SInput_packetInfoFromJSON(object: any): MessageC2SInput_packetInfo {
  switch (object) {
    case 0:
    case "unknown":
      return MessageC2SInput_packetInfo.unknown;
    case 11:
    case "type":
      return MessageC2SInput_packetInfo.type;
    case -1:
    case "UNRECOGNIZED":
    default:
      return MessageC2SInput_packetInfo.UNRECOGNIZED;
  }
}

export function messageC2SInput_packetInfoToJSON(object: MessageC2SInput_packetInfo): string {
  switch (object) {
    case MessageC2SInput_packetInfo.unknown:
      return "unknown";
    case MessageC2SInput_packetInfo.type:
      return "type";
    case MessageC2SInput_packetInfo.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

function createBaseMessageC2SHello(): MessageC2SHello {
  return { version: 0, requestedUsername: "", nextState: 0 };
}

export const MessageC2SHello = {
  encode(message: MessageC2SHello, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.version !== 0) {
      writer.uint32(8).uint32(message.version);
    }
    if (message.requestedUsername !== "") {
      writer.uint32(18).string(message.requestedUsername);
    }
    if (message.nextState !== 0) {
      writer.uint32(24).int32(message.nextState);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MessageC2SHello {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageC2SHello();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag != 8) {
            break;
          }

          message.version = reader.uint32();
          continue;
        case 2:
          if (tag != 18) {
            break;
          }

          message.requestedUsername = reader.string();
          continue;
        case 3:
          if (tag != 24) {
            break;
          }

          message.nextState = reader.int32() as any;
          continue;
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): MessageC2SHello {
    return {
      version: isSet(object.version) ? Number(object.version) : 0,
      requestedUsername: isSet(object.requestedUsername) ? String(object.requestedUsername) : "",
      nextState: isSet(object.nextState) ? stateFromJSON(object.nextState) : 0,
    };
  },

  toJSON(message: MessageC2SHello): unknown {
    const obj: any = {};
    message.version !== undefined && (obj.version = Math.round(message.version));
    message.requestedUsername !== undefined && (obj.requestedUsername = message.requestedUsername);
    message.nextState !== undefined && (obj.nextState = stateToJSON(message.nextState));
    return obj;
  },

  create<I extends Exact<DeepPartial<MessageC2SHello>, I>>(base?: I): MessageC2SHello {
    return MessageC2SHello.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<MessageC2SHello>, I>>(object: I): MessageC2SHello {
    const message = createBaseMessageC2SHello();
    message.version = object.version ?? 0;
    message.requestedUsername = object.requestedUsername ?? "";
    message.nextState = object.nextState ?? 0;
    return message;
  },
};

function createBaseMessageC2SGoodbye(): MessageC2SGoodbye {
  return { reason: 0 };
}

export const MessageC2SGoodbye = {
  encode(message: MessageC2SGoodbye, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.reason !== 0) {
      writer.uint32(8).int32(message.reason);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MessageC2SGoodbye {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageC2SGoodbye();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag != 8) {
            break;
          }

          message.reason = reader.int32() as any;
          continue;
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): MessageC2SGoodbye {
    return { reason: isSet(object.reason) ? goodbyeReasonFromJSON(object.reason) : 0 };
  },

  toJSON(message: MessageC2SGoodbye): unknown {
    const obj: any = {};
    message.reason !== undefined && (obj.reason = goodbyeReasonToJSON(message.reason));
    return obj;
  },

  create<I extends Exact<DeepPartial<MessageC2SGoodbye>, I>>(base?: I): MessageC2SGoodbye {
    return MessageC2SGoodbye.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<MessageC2SGoodbye>, I>>(object: I): MessageC2SGoodbye {
    const message = createBaseMessageC2SGoodbye();
    message.reason = object.reason ?? 0;
    return message;
  },
};

function createBaseMessageC2SChat(): MessageC2SChat {
  return { message: "" };
}

export const MessageC2SChat = {
  encode(message: MessageC2SChat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.message !== "") {
      writer.uint32(10).string(message.message);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MessageC2SChat {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageC2SChat();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag != 10) {
            break;
          }

          message.message = reader.string();
          continue;
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): MessageC2SChat {
    return { message: isSet(object.message) ? String(object.message) : "" };
  },

  toJSON(message: MessageC2SChat): unknown {
    const obj: any = {};
    message.message !== undefined && (obj.message = message.message);
    return obj;
  },

  create<I extends Exact<DeepPartial<MessageC2SChat>, I>>(base?: I): MessageC2SChat {
    return MessageC2SChat.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<MessageC2SChat>, I>>(object: I): MessageC2SChat {
    const message = createBaseMessageC2SChat();
    message.message = object.message ?? "";
    return message;
  },
};

function createBaseMessageC2SPing(): MessageC2SPing {
  return {};
}

export const MessageC2SPing = {
  encode(_: MessageC2SPing, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MessageC2SPing {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageC2SPing();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): MessageC2SPing {
    return {};
  },

  toJSON(_: MessageC2SPing): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<MessageC2SPing>, I>>(base?: I): MessageC2SPing {
    return MessageC2SPing.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<MessageC2SPing>, I>>(_: I): MessageC2SPing {
    const message = createBaseMessageC2SPing();
    return message;
  },
};

function createBaseMessageC2SInput(): MessageC2SInput {
  return { upPressed: false, downPressed: false, leftPressed: false, rightPressed: false };
}

export const MessageC2SInput = {
  encode(message: MessageC2SInput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.upPressed === true) {
      writer.uint32(8).bool(message.upPressed);
    }
    if (message.downPressed === true) {
      writer.uint32(16).bool(message.downPressed);
    }
    if (message.leftPressed === true) {
      writer.uint32(24).bool(message.leftPressed);
    }
    if (message.rightPressed === true) {
      writer.uint32(32).bool(message.rightPressed);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MessageC2SInput {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageC2SInput();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag != 8) {
            break;
          }

          message.upPressed = reader.bool();
          continue;
        case 2:
          if (tag != 16) {
            break;
          }

          message.downPressed = reader.bool();
          continue;
        case 3:
          if (tag != 24) {
            break;
          }

          message.leftPressed = reader.bool();
          continue;
        case 4:
          if (tag != 32) {
            break;
          }

          message.rightPressed = reader.bool();
          continue;
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): MessageC2SInput {
    return {
      upPressed: isSet(object.upPressed) ? Boolean(object.upPressed) : false,
      downPressed: isSet(object.downPressed) ? Boolean(object.downPressed) : false,
      leftPressed: isSet(object.leftPressed) ? Boolean(object.leftPressed) : false,
      rightPressed: isSet(object.rightPressed) ? Boolean(object.rightPressed) : false,
    };
  },

  toJSON(message: MessageC2SInput): unknown {
    const obj: any = {};
    message.upPressed !== undefined && (obj.upPressed = message.upPressed);
    message.downPressed !== undefined && (obj.downPressed = message.downPressed);
    message.leftPressed !== undefined && (obj.leftPressed = message.leftPressed);
    message.rightPressed !== undefined && (obj.rightPressed = message.rightPressed);
    return obj;
  },

  create<I extends Exact<DeepPartial<MessageC2SInput>, I>>(base?: I): MessageC2SInput {
    return MessageC2SInput.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<MessageC2SInput>, I>>(object: I): MessageC2SInput {
    const message = createBaseMessageC2SInput();
    message.upPressed = object.upPressed ?? false;
    message.downPressed = object.downPressed ?? false;
    message.leftPressed = object.leftPressed ?? false;
    message.rightPressed = object.rightPressed ?? false;
    return message;
  },
};

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin ? T
  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}