import { defineApp } from 'redweb';
import { HomePage, DashboardPage } from './pages.js';
import { MatchRoute, ChatRoute } from './sockets.js';
import { GameSimulation } from './simulation.js';

const app = defineApp({
  pages: [HomePage, DashboardPage],
  sockets: [MatchRoute, ChatRoute],
  services: [GameSimulation],
});

await app.run();

import { HttpServer, METHODS } from 'redweb'

const server = new HttpServer({
  port: 4000,
  bind: '0.0.0.0',
  publicPaths: ['./static'],
  services: [
    { serviceName: '/ping', method: METHODS.GET, function: (req, res) => res.json({ pong: true }) },
  ],
})

// Express is still available:
server.app.get('/health', (req, res) => res.send('ok'))

import { BaseHttpServer, METHODS } from 'redweb'

const base = new BaseHttpServer({
  publicPaths: ['./public'],
  services: [
    { serviceName: '/health', method: METHODS.GET, function: (req, res) => res.json({ ok: true }) },
  ],
})

base.app.get('/extra', (req, res) => res.send('ok'))

import { HttpsServer, METHODS } from 'redweb'

new HttpsServer({
  port: 4443,
  ssl: { key: './certs/dev.key', cert: './certs/dev.crt' },
  services: [
    { serviceName: '/secure', method: METHODS.GET, function: (req, res) => res.json({ ok: true }) },
  ],
})

import { HttpServer, SocketServer } from 'redweb'
import { ChatRoute } from './ChatRoute.js'

// Advanced: attach to a listener whose lifecycle your application owns.
const http = new HttpServer({ listen: false, publicPaths: [] })
const sockets = new SocketServer({ server: http.server, routes: [ChatRoute] })

http.server.listen(3030)

// At application shutdown, detach sockets before closing their shared listener.
async function shutdown() {
  await sockets.shutdown()
  await http.shutdown()
}

import { SecureSocketServer } from 'redweb'
import { GameRoute } from './routes/GameRoute.js'

new SecureSocketServer({
  port: 3443,
  ssl: { key: './certs/dev.key', cert: './certs/dev.crt' },
  routes: [GameRoute],
})

import { SocketRoute } from 'redweb'
import { ChatHandler } from './handlers/ChatHandler.js'
import { ClockService } from './services/ClockService.js'

class ChatRoute extends SocketRoute {
  constructor() {
    super({
      path: '/chat',
      handlers: [ChatHandler],
      services: [ClockService],
      allowDuplicateConnections: true,
      websocketOptions: {
        maxPayload: 1024 * 1024,
        perMessageDeflate: false,
      },
    })
  }
}

import { SocketService } from 'redweb'

class ClockService extends SocketService {
  constructor() { super('clock', 1000) }
  onTick() {
    this.route.clients.forEach((socket) => socket.sendJson({ type: 'time', now: Date.now() }))
  }
}

import { FixedStepService } from 'redweb'

class Simulation extends FixedStepService {
  constructor() { super('simulation', 50, 3) }
  async onTick(stepMs, tick) {
    await game.update(stepMs, tick)
  }
}

class MatchRoute extends SocketRoute {
  constructor() {
    super({
      path: '/match',
      handlers: [JoinMatchHandler, MoveMatchHandler, ResumeMatchHandler],
      rooms: { maxRooms: 1000, maxMembersPerRoom: 32 },
    })
  }
}

class MatchRoute extends SocketRoute {
  constructor() {
    super({
      path: '/match',
      handlers: [JoinMatchHandler, MoveMatchHandler, ResumeMatchHandler],
      sessions: { ttlMs: 30000, maxSessions: 10000 },
    })
  }
}

import { ProtocolClient } from 'redweb/client'

const socket = new WebSocket('wss://game.example/match?redwebVersion=1')
const client = new ProtocolClient(socket, '1')

socket.addEventListener('open', () => {
  client.send('move', { x: 4, y: 2 }, { sequence: 17 })
})

socket.addEventListener('message', event => {
  try {
    const message = client.parse(event)
    console.log(message)
  } catch (error) {
    console.error('Invalid server envelope', error)
  }
})

import { SocketRegistry } from 'redweb'

const players = new SocketRegistry()
players.on('added', player => console.log('Joined:', player.id))
players.add({ id: 'alice' })
players.remove('alice')

import { BaseHandler } from 'redweb'

class UploadHandler extends BaseHandler {
  constructor() { super('upload') }

  onMessage(socket, message) {
    socket.sendJson({ type: 'upload:ready' })
  }

  acceptsBinary(socket, buffer) {
    return buffer.length > 0
  }

  onBinaryMessage(socket, buffer) {
    socket.sendJson({ type: 'upload:chunk', bytes: buffer.length })
  }
}

import { sendJson } from 'redweb'

// Route handler: respects the route's transport policy.
socket.sendJson({ type: 'ping' })

// Raw socket you own: serialization/send only.
sendJson(rawSocket, { type: 'ping' })

import { ERROR_CODES } from 'redweb'

// INVALID_MESSAGE, UNKNOWN_HANDLER, HANDLER_FAILED,
// BINARY_UNSUPPORTED, RATE_LIMITED, QUEUE_FULL,
// CAPACITY_REACHED, INITIALIZATION_FAILED

import { SOCKET_OPTIONS } from 'redweb'
// { port: 3000, ssl: null, listen: true, routes: [] }

import { HTTP_OPTIONS } from 'redweb'
// port 80, bind 0.0.0.0, publicPaths ['./public'],
// listen true, encoding 'json', and safe error exposure disabled

import { ENCODINGS } from 'redweb'
// ENCODINGS.json, ENCODINGS.urlencoded

import { METHODS } from 'redweb'
// METHODS.GET, METHODS.POST, METHODS.PUT, METHODS.DELETE

import { BaseSocketServer } from 'redweb'

// SocketServer and SecureSocketServer inherit:
// addRoute(), handleUpgrade(), beginDrain(), and shutdown().

import { LiveHtmlServer } from 'redweb'
import { DocsPage, StatusPage } from './pages.js'

const server = new LiveHtmlServer({
  pages: [DocsPage, StatusPage],
  port: 8080,
  heartbeat: { intervalMs: 15_000, timeoutMs: 10_000 },
})

import { action, defineApp, page, state } from 'redweb';

@page('/', { shared: true })
class CounterPage {
    @state() count = 0;

    @action()
    increment() { this.count += 1; }

    render() {
        return <button rw-click="increment">Count {this.count}</button>;
    }
}

const app = defineApp({ pages: [CounterPage] });
app.run();

import { action, defineApp, page, state } from 'redweb';

@page('/', { shared: true })
class CounterPage {
    @state() count = 0;

    @action()
    increment() { this.count += 1; }

    render() {
        return <button rw-click="increment">Count {this.count}</button>;
    }
}

const app = defineApp({ pages: [CounterPage] });
app.run();

// Start with npx redweb init; keep this source in a .tsx file.
import { defineApp, page } from 'redweb'
import type { Child } from 'redweb/jsx-runtime'

function Card({ title, children }: { title: string; children?: Child }) {
  return <article><h2>{title}</h2>{children}</article>
}

@page('/', { live: false })
class HomePage {
  render() { return <Card title="Redweb">Readable server TSX</Card> }
}

const app = defineApp({ pages: [HomePage] })
app.run()

import { codeBlock, each, html } from 'redweb'

const links = sections.map(section => ({
  id: section.id,
  href: `#${section.id}`,
  label: section.name,
}))

const navigation = each(links, link => html`
  <a id="${link.id}" href="${link.href}">${link.label}</a>
`)

// TS, TSX and JS highlight automatically, including rw-* action references.
const example = codeBlock(source, { language: 'tsx', label: 'TypeScript' })

import { defineSite } from 'redweb'

const docs = defineSite({
  origin: 'https://example.com',
  css: 'site.css',
  head: { description: 'Product documentation', image: '/og.png' },
  cache: { maxAge: 300 },
  layout: content => <body><nav>Product</nav><main>{content}</main></body>,
})

@docs.page('/docs', { head: { title: 'Documentation' } })
class DocsPage {
  render() { return <h1>Documentation</h1> }
}

await docs.export(DocsPage, {
  outDir: 'dist',
  publicDir: 'public',
})

import { exportStatic, page } from 'redweb'

@page('/docs', { live: false })
class DocsPage {
  render() { return <h1>Redweb docs</h1> }
}

await exportStatic(DocsPage, { outDir: 'dist' })

import { HtmlRenderer } from 'redweb'

const markup = HtmlRenderer.render(
  '<h1>{{ title }}</h1>',
  { title: 'Reference' },
  { live: false },
)

const document = HtmlRenderer.document(markup, null, [], {
  title: 'Reference',
})

import { defineSocketContract } from 'redweb/contract';
import { z } from 'zod';

const position = { x: z.number().int().min(-100).max(100), y: z.number().int().min(-100).max(100) };

// Share this module with a browser or Node client. It imports no server application code.
export const match = defineSocketContract('1', {
    join: z.object({ name: z.string().trim().min(1).max(40) }).strict(),
    move: z.object(position).strict(),
    resume: z.object({ session: z.string().uuid() }).strict(),
    state: z.object({ session: z.string().uuid(), name: z.string(), ...position }).strict(),
});

import { connectedClients } from 'redweb'

// Supply your authenticated account lookup, game service, page and contract.
const players = connectedClients({
  identity: context => account(context.request),
  page: () => GamePage,
  project: (player, room, online) => ({
    game: games.resume(room, player.identity).snapshot(player.identity),
    online,
  }),
})
const match = players.bind(contract)
const Join = match.handler('join', (player, { room }) =>
  player.join(room, () => games.join(room, player.identity)))

// Register connections: players and protocol: match.protocol on MatchRoute.
// Attach GamePage with @page('/', { socket: MatchRoute }).
// Its TSX form uses rw-submit={Join}.