export interface AgentConnection<Name extends string = string> {
  readonly agent: AgentHandle<Name>;
}

export class AgentHandle<
  Name extends string = string,
> extends ParticipantHandle<Name> {
  readonly [agentHandleTypeId] = agentHandleTypeId;

  private constructor(name: Name, id: AgentId) {
    super(name, id);
  }

  static [agentHandleConstruction]<const Name extends string>(
    name: Name,
    id: AgentId,
  ): AgentHandle<Name> {
    return new AgentHandle(name, id);
  }
}

export interface AttachedEndpoint<Name extends string> {
  readonly participant: ParticipantHandle<Name>;
  readonly transport: EndpointTransport;
}

export class Endpoint<Name extends string = string> {
  readonly [endpointTypeId] = endpointTypeId;

  readonly participant: ParticipantHandle<Name>;
  private readonly inbox: EndpointInbox;
  private readonly transport: EndpointTransport;

  private constructor(
    participant: ParticipantHandle<Name>,
    transport: EndpointTransport,
    inbox: EndpointInbox,
  ) {
    this.participant = participant;
    this.transport = transport;
    this.inbox = inbox;
  }

  static [endpointConstruction]<const Name extends string>(
    attachment: AttachedEndpoint<Name>,
    inbox: EndpointInbox,
  ): Endpoint<Name> {
    return new Endpoint(attachment.participant, attachment.transport, inbox);
  }

  /**
   * Send one explicit addressed post through the endpoint daemon.
   * @param input Explicit destination and nonempty content.
   * @returns Completion after the daemon certifies the addressed post.
   */
  send(input: SendInput): Effect.Effect<void, NetworkError> {
    return this.transport.send(input);
  }

  /**
   * Observe addressed deliveries emitted after this stream is subscribed.
   * @returns A live fan-out stream of deliveries for this endpoint.
   */
  messages(): Stream.Stream<InboundDelivery, NetworkError> {
    return this.inbox.messages;
  }
}

export interface EndpointInbox {
  /** Live fan-out stream for observers of every endpoint delivery. */
  readonly messages: Stream.Stream<InboundDelivery, NetworkError>;
}

export interface EndpointTransport {
  readonly received: Stream.Stream<InboundDelivery, NetworkError>;
  readonly send: (input: SendInput) => Effect.Effect<void, NetworkError>;
}

export type InboundLinkStage = <
  A extends { readonly message: SignedMessage },
  E,
>(
  inbound: Stream.Stream<A, E>,
) => Stream.Stream<A, E>;

export class LinkController extends Context.Tag(
  "@moltzap/simulator/LinkController",
)<LinkController, LinkControllerService>() {}

export interface LinkControllerService {
  /**
   * Keep one directed link disabled for the lifetime of the current Scope.
   * Overlapping acquisitions share a single physical down/up transition.
   */
  readonly disable: (
    from: ParticipantHandle,
    to: ParticipantHandle,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Delay every delivery on one directed link for the current Scope. */
  readonly delay: (
    from: ParticipantHandle,
    to: ParticipantHandle,
    duration: Duration.DurationInput,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Park every delivery on one directed link for the current Scope. */
  readonly hold: (
    from: ParticipantHandle,
    to: ParticipantHandle,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Install one custom policy on a directed link for the current Scope. */
  readonly shape: (
    from: ParticipantHandle,
    to: ParticipantHandle,
    policy: LinkPolicy,
    description: string,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
}

export interface LinkDelivery {
  /** Message sender identity. */
  readonly from: AgentId;
  /** Receiving participant identity. */
  readonly to: AgentId;
  /** Identity-owned opaque signed message carried by the delivery. */
  readonly message: SignedMessage;
}

export class LinkDriver extends Context.Tag("@moltzap/simulator/LinkDriver")<
  LinkDriver,
  LinkDriverService
>() {}

export interface LinkDriverService {
  readonly disable: (
    from: AgentId,
    to: AgentId,
  ) => Effect.Effect<void, NetworkError>;
  readonly enable: (
    from: AgentId,
    to: AgentId,
  ) => Effect.Effect<void, NetworkError>;
  /**
   * Install one policy on a directed link until the returned lease clears.
   * Policies stack in installation order on the same link. The same
   * pre-permit/post-linearization interruption rule applies to `clear`.
   */
  readonly apply: (
    from: AgentId,
    to: AgentId,
    policy: LinkPolicy,
    description: string,
  ) => Effect.Effect<LinkPolicyLease, NetworkError>;
}

export const linkPolicy:

export type LinkPolicy = (delivery: LinkDelivery) => Effect.Effect<LinkVerdict>;

export interface LinkPolicyLease {
  readonly clear: Effect.Effect<void, NetworkError>;
}

export const linkVerdict = Data.taggedEnum<LinkVerdict>()

export type LinkVerdict = Data.TaggedEnum<{
  deliver: Record<never, never>;
  drop: { readonly reason?: string };
  delay: { readonly duration: Duration.Duration };
  hold: Record<never, never>;
}>;

export function makeAgentHandle<const Name extends string>(
  name: Name,
  id: AgentId,
): AgentHandle<Name>

export function makeEndpoint<const Name extends string>(
  attachment: AttachedEndpoint<Name>,
  inbox: EndpointInbox,
): Endpoint<Name>

export function makeParticipantHandle<const Name extends string>(
  name: Name,
  id: AgentId,
): ParticipantHandle<Name>

export function makeRouterStopReport(): RouterStopped

export class Network extends Context.Tag("@moltzap/simulator/Network")<
  Network,
  NetworkService
>() {}

export function networkError(
  operation: NetworkOperation,
  cause: unknown,
): NetworkError

export class NetworkError extends Schema.TaggedError<NetworkError>()(
  "NetworkError",
  {
    operation: networkOperation,
    detail: Schema.String,
  },
) {
  override get message(): string {
    return `Network ${this.operation} failed: ${this.detail}`;
  }
}

export type NetworkOperation = typeof networkOperation.Type;

export interface NetworkService {
  endpoint<const Name extends string>(
    name: Name,
  ): Effect.Effect<Endpoint<Name>, NetworkError>;
}

export class ParticipantHandle<Name extends string = string> {
  readonly [participantHandleTypeId] = participantHandleTypeId;

  readonly name: Name;
  readonly id: AgentId;

  protected constructor(name: Name, id: AgentId) {
    this.name = name;
    this.id = id;
  }

  static [participantHandleConstruction]<const Name extends string>(
    name: Name,
    id: AgentId,
  ): ParticipantHandle<Name> {
    return new ParticipantHandle(name, id);
  }
}

export type ParticipantIds = readonly [AgentId, ...(readonly AgentId[])];

export interface Router {
  readonly address: URL;

  /** Awaits the stop report completed by scoped release. */
  readonly stopped: Effect.Effect<RouterStopped, NetworkError>;
}

export class RouterProvider extends Context.Tag(
  "@moltzap/simulator/RouterProvider",
)<RouterProvider, RouterProviderService>() {}

export interface RouterProviderService {
  readonly acquire: Effect.Effect<Router, NetworkError, Scope.Scope>;
}

export class RouterStopped {
  readonly [routerStoppedTypeId]: typeof routerStoppedTypeId;

  private constructor() {
    this[routerStoppedTypeId] = routerStoppedTypeId;
  }

  static [routerStoppedConstruction](): RouterStopped {
    return new RouterStopped();
  }
}