export const agentCallableNetworkRpcMethods = [
  AgentConnect,
  AgentPresenceSubscribe,
] as const

export const AgentConnect = defineRpc({
  name: "agent/network/connect",
  params: Schema.Struct({
    agentKey: AgentKey,
    minProtocol: Schema.String,
    maxProtocol: Schema.String,
  }),
  result: HelloOkSchema,
  requires: [],
  errors: [
    InvalidParamsError,
    UnauthorizedError,
    ProtocolMismatchError,
    AlreadyConnected,
  ],
})

export const AgentPresenceSubscribe = defineRpc({
  name: "agent/network/presence/subscribe",
  params: PresenceSubscribeParamsSchema,
  result: PresenceSubscribeResultSchema,
  requires: [AgentPrincipal],
  errors: [NotInContactsError],
})

export const appCallableNetworkRpcMethods = [
  AppConnect,
  AppPresenceSubscribe,
] as const

export const AppConnect = defineRpc({
  name: "app/network/connect",
  params: Schema.Struct({
    appKey: AppKey,
    minProtocol: Schema.String,
    maxProtocol: Schema.String,
  }),
  result: HelloOkSchema,
  requires: [],
  errors: [
    InvalidParamsError,
    UnauthorizedError,
    ProtocolMismatchError,
    AlreadyConnected,
  ],
})

export const AppPresenceSubscribe = defineRpc({
  name: "app/network/presence/subscribe",
  params: PresenceSubscribeParamsSchema,
  result: PresenceSubscribeResultSchema,
  requires: [AppPrincipal],
  errors: [],
})

export function checkProtocolRange(
  params: { readonly minProtocol: string; readonly maxProtocol: string },
  serverVersion: string,
): Effect.Effect<void, ProtocolMismatchError | InvalidProtocolVersionError>

export function compareProtocolVersion(a: string, b: string): -1 | 0 | 1

export type HelloOk = Schema.Schema.Type<typeof HelloOkSchema>;

export class InvalidProtocolVersionError extends Data.TaggedError(
  "InvalidProtocolVersionError",
)<{ readonly version: string; readonly segment: string }> {
  override get message(): string {
    return `compareProtocolVersion: invalid segment ${JSON.stringify(this.segment)} in ${JSON.stringify(this.version)}`;
  }
}

export const networkNotifications = [] as const

export const networkRpcMethods = [
  AgentConnect,
  AppConnect,
  AgentPresenceSubscribe,
  AppPresenceSubscribe,
] as const

export const PROTOCOL_VERSION = packageJson.version

export class ProtocolMismatchError extends Schema.TaggedError<ProtocolMismatchError>()(
  "ProtocolMismatchError",
  {
    message: Schema.optional(Schema.String),
    data: Schema.Struct({
      reason: Schema.Literal(
        "server-above-client-max",
        "server-below-client-min",
      ),
      serverVersion: Schema.String,
      clientMinProtocol: Schema.String,
      clientMaxProtocol: Schema.String,
    }),
  },
) {
  static readonly message = "Client protocol version not supported";
}

export type ProtocolMismatchReason =
  | "server-above-client-max"
  | "server-below-client-min";

/**
 * Raised by connect methods when the client's `[minProtocol, maxProtocol]`
 * range does not bracket the server's `PROTOCOL_VERSION`. The server's connect
 * handlers raise it BEFORE auth resolution
 * so old clients are rejected at the version gate. `data` carries the
 * diagnostic `{ reason, serverVersion, clientMinProtocol, clientMaxProtocol }`,
 * concretely typed so `error.data.reason` narrows at every reader.
 */
export class ProtocolMismatchError extends Schema.TaggedError<ProtocolMismatchError>()(
  "ProtocolMismatchError",
  {
    message: Schema.optional(Schema.String),
    data: Schema.Struct({
      reason: Schema.Literal(
        "server-above-client-max",
        "server-below-client-min",
      ),
      serverVersion: Schema.String,
      clientMinProtocol: Schema.String,
      clientMaxProtocol: Schema.String,
    }),
  },
) {
  static readonly message = "Client protocol version not supported";
}