import { Effect, Fiber, Option } from 'effect'
import { type AnyScene, type WirePatch, type WireTree } from '@playfast/reform/internal'
import { makeRemoteServer } from './server'

export interface SnapshotMessage {
  readonly _tag: 'Snapshot'
  readonly tree: WireTree
}

export interface PatchesMessage {
  readonly _tag: 'Patches'
  readonly patches: ReadonlyArray<WirePatch>
}

export type ServerMessage = SnapshotMessage | PatchesMessage

export interface InvokeMessage {
  readonly _tag: 'Invoke'
  readonly handle: string
  readonly payload: unknown
}

export interface RemoteTransport<Out, In> {
  readonly send: (message: Out) => void
  readonly onMessage: (handler: (message: In) => void) => () => void
}

export interface ServerBinding {
  readonly start: () => Promise<void>
  readonly dispose: () => Promise<void>
}

const BACKGROUND_FLUSH_MS = 16

export interface ServeOptions {
  readonly scene: AnyScene
  readonly transport: RemoteTransport<ServerMessage, InvokeMessage>
}

export const serve = (options: ServeOptions): ServerBinding => {
  const { scene, transport } = options
  const server = makeRemoteServer(scene)
  // Snapshot gates diffs; single-flight rendering protects the shared frame baseline.
  const started = { value: false }
  const flight = { promise: Option.none<Promise<void>>(), dirty: false }
  const push = (): Promise<void> => {
    if (!started.value) {
      return Effect.runPromise(Effect.void)
    }
    if (Option.isSome(flight.promise)) {
      flight.dirty = true
      return flight.promise.value
    }
    // ensuring clears the single-flight slot even when rendering fails.
    const run = Effect.runPromise(
      Effect.gen(function* () {
        const patches = yield* Effect.promise(() => server.renderDiff())
        if (patches.length > 0) {
          transport.send({ _tag: 'Patches', patches })
        }
      }).pipe(
        Effect.ensuring(
          Effect.sync(() => {
            flight.promise = Option.none()
            if (flight.dirty) {
              flight.dirty = false
              void push()
            }
          }),
        ),
      ),
    )
    flight.promise = Option.some(run)
    return run
  }
  // Background debounce lets the drain settle and coalesces bursts without delaying invokes.
  const debounce = { fiber: Option.none<Fiber.RuntimeFiber<void>>() }
  const scheduleFlush = (): void => {
    if (!started.value || Option.isSome(debounce.fiber)) {
      return
    }
    const fiber = Effect.runFork(
      Effect.sleep(BACKGROUND_FLUSH_MS).pipe(
        Effect.zipRight(
          Effect.sync(() => {
            debounce.fiber = Option.none()
            void push()
          }),
        ),
      ),
    )
    debounce.fiber = Option.some(fiber)
  }
  const start = async (): Promise<void> => {
    const tree = await server.render()
    transport.send({ _tag: 'Snapshot', tree })
    started.value = true
    scheduleFlush()
  }
  const off = transport.onMessage((message) => {
    void Effect.runPromise(
      Effect.promise(() => server.invoke(message.handle, message.payload)).pipe(
        Effect.zipRight(Effect.promise(push)),
        // A stale handle (its node was deleted by a patch still in flight) fails by
        // design. Left unhandled that escapes as a rejected promise and, under Node's
        // default --unhandled-rejections=throw, takes the server down for every client.
        Effect.catchAllCause((cause) =>
          Effect.logError(`reform-remote: invoke '${message.handle}' failed`, cause),
        ),
      ),
    )
  })
  const offChange = server.subscribe(scheduleFlush)
  return {
    start,
    dispose: async (): Promise<void> => {
      off()
      offChange()
      if (Option.isSome(debounce.fiber)) {
        Effect.runFork(Fiber.interrupt(debounce.fiber.value))
      }
      await server.dispose()
    },
  }
}

export interface SharedClientHandle {
  readonly remove: () => void
}

export interface SharedServerBinding {
  readonly addClient: (
    transport: RemoteTransport<ServerMessage, InvokeMessage>,
  ) => SharedClientHandle
  readonly dispose: () => Promise<void>
}

export interface ServeSharedOptions {
  readonly scene: AnyScene
}

export const serveShared = (options: ServeSharedOptions): SharedServerBinding => {
  const { scene } = options
  const server = makeRemoteServer(scene)
  const clients = new Set<RemoteTransport<ServerMessage, InvokeMessage>>()
  const broadcast = (message: ServerMessage): void => {
    clients.forEach((client) => client.send(message))
  }

  // One shared render baseline requires the same single-flight discipline as serve.
  const started = { value: false }
  const flight = { promise: Option.none<Promise<void>>(), dirty: false }
  const push = (): Promise<void> => {
    if (!started.value) {
      return Effect.runPromise(Effect.void)
    }
    if (Option.isSome(flight.promise)) {
      flight.dirty = true
      return flight.promise.value
    }
    const run = Effect.runPromise(
      Effect.gen(function* () {
        const patches = yield* Effect.promise(() => server.renderDiff())
        if (patches.length > 0) {
          broadcast({ _tag: 'Patches', patches })
        }
      }).pipe(
        Effect.ensuring(
          Effect.sync(() => {
            flight.promise = Option.none()
            if (flight.dirty) {
              flight.dirty = false
              void push()
            }
          }),
        ),
      ),
    )
    flight.promise = Option.some(run)
    return run
  }

  const debounce = { fiber: Option.none<Fiber.RuntimeFiber<void>>() }
  const scheduleFlush = (): void => {
    if (!started.value || Option.isSome(debounce.fiber)) {
      return
    }
    const fiber = Effect.runFork(
      Effect.sleep(BACKGROUND_FLUSH_MS).pipe(
        Effect.zipRight(
          Effect.sync(() => {
            debounce.fiber = Option.none()
            void push()
          }),
        ),
      ),
    )
    debounce.fiber = Option.some(fiber)
  }

  // Clients await the initial baseline so none snapshot an empty tree.
  const ready = (async (): Promise<void> => {
    await server.render()
    started.value = true
    scheduleFlush()
  })()

  const offChange = server.subscribe(scheduleFlush)

  const addClient = (
    transport: RemoteTransport<ServerMessage, InvokeMessage>,
  ): SharedClientHandle => {
    const off = transport.onMessage((message) => {
      void Effect.runPromise(
        Effect.promise(() => server.invoke(message.handle, message.payload)).pipe(
          Effect.zipRight(Effect.promise(push)),
          // A stale handle (its node was deleted by a patch still in flight) fails by
          // design. Left unhandled that escapes as a rejected promise and, under Node's
          // default --unhandled-rejections=throw, takes the server down for every client.
          Effect.catchAllCause((cause) =>
            Effect.logError(`reform-remote: invoke '${message.handle}' failed`, cause),
          ),
        ),
      )
    })
    // Snapshot and broadcast membership must change in one tick so no diff interleaves.
    void Effect.runPromise(
      Effect.promise(() => ready).pipe(
        Effect.zipRight(
          Effect.sync(() => {
            transport.send({ _tag: 'Snapshot', tree: server.currentTree() })
            clients.add(transport)
          }),
        ),
      ),
    )
    return {
      remove: (): void => {
        off()
        clients.delete(transport)
      },
    }
  }

  return {
    addClient,
    dispose: async (): Promise<void> => {
      offChange()
      if (Option.isSome(debounce.fiber)) {
        Effect.runFork(Fiber.interrupt(debounce.fiber.value))
      }
      clients.clear()
      await server.dispose()
    },
  }
}

export { type ClientBinding, connect, type ConnectOptions } from './clientBinding'