const http = require('http')
const url = require('url')

const app = http.createServer((req, res) => {
   const parsedURL = url.parse(req.url, true)
   if (parsedURL.pathname === '/api') {
      res.setHeader('content-type', 'text/plain; charset=utf-8')
      res.end(`Hey ${parsedURL.query.name} ${parsedURL.query.lastname}`)
   }
})

app.listen(4000)

const express = require('express')
const app = express()

app.get('/', function (req, res) {
  res.send('Hello World')
})
const port = 3000;
app.listen(port, () => {
    console.log(`Example app listening on port ${port}`)
  })
  app.get('/api/:name/:age', (req, res) => {
    console.log(req.params)
    res.send({
        'name': req.params.name,
    })
  })

const express = require("express");
const app = express();

// GET method route
app.get("/", (req, res) => {
  res.send("sddsaf");
});
app.get("/api/:name/:age", (req, res) => {
  console.log(req.params);
  res.send({
    name: req.params.name,
  });
});

// POST method route
app.post("/", (req, res) => {
  res.send("POST request to the homepage");
});
const myLogger = function (req, res, next) {
  console.log("LOGGED");
  next();
};
app.use(myLogger);

app.all("/secret", (req, res, next) => {
  console.log("Accessing the secret section ...");
  next(); // pass control to the next handler
});
const port = 3000;
app.listen(port, () => {
  console.log(`Example app listening on port ${port}`);
});

const router = express.Router()

router.use((req, res, next) => {
  console.log('Time:', Date.now())
  next()
})

// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', (req, res, next) => {
  console.log('Request URL:', req.originalUrl)
  next()
}, (req, res, next) => {
  console.log('Request Type:', req.method)
  next()
})
// handler for the /user/:id path, which renders a special page
router.get('/user/:id', (req, res, next) => {
  console.log(req.params.id)
  res.render('special')
})

// mount the router on the app
app.use('/', router)

const express = require('express')
const app = express()
const router = express.Router()

// predicate the router with a check and bail out when needed
router.use((req, res, next) => {
  if (!req.headers['x-auth']) return next('router')
  next()
})

router.get('/user/:id', (req, res) => {
  res.send('hello, user!')
})

// use the router and 401 anything falling through
app.use('/admin', router, (req, res) => {
  res.sendStatus(401)
})

app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})

const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')

// load the cookie-parsing middleware
app.use(cookieParser())

app.response.sendStatus = function (statusCode, type, message) {
  // code is intentionally kept simple for demonstration purpose
  return this.contentType(type)
    .status(statusCode)
    .send(message)
}

Object.defineProperty(app.request, 'ip', {
  configurable: true,
  enumerable: true,
  get () { return this.get('Client-IP') }
})

app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})

npm i koa

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

const Koa = require('koa');
const app = new Koa();

// logger

app.use(async (ctx, next) => {
  console.log("logger")
  await next();
  console.log("Hello")
  const rt = ctx.response.get('X-Response-Time');
  console.log(`${ctx.method} ${ctx.url} - ${rt}`);
});

// x-response-time

app.use(async (ctx, next) => {
  const start = Date.now();
  console.log("res")
  await next();
  const ms = Date.now() - start;
  console.log(ms)
  ctx.set('X-Response-Time', `${ms}ms`);
});

// response

app.use(async ctx => {
    console.log("start")
    // html
  ctx.body = 'Hello World';
    // json
   // ctx.body = { foo: 'bar' };
});

app.listen(3000);

app.context.db = db();

app.use(async ctx => {
  console.log(ctx.db);
});

const Koa = require('koa');
const Router = require('koa-router');

const app = new Koa();
const router = new Router();

router.get('/', async (ctx) => {
  ctx.body = 'Home Page';
});

router.get('/about', async (ctx) => {
  ctx.body = 'About Page';
});

app.use(router.routes());

app.listen(3000, () => {
  console.log('Server started on port 3000');
});

app.on('error', (err, ctx) => {
  log.error('server error', err, ctx)
});

const fastify = require("fastify")
const app = fastify()

app.get("/api", (req, res) => {
  res.send(`Hey ${req.query.name} ${req.query.name}`)
})

app.listen(4000)

const fastify = require("fastify")
const app = fastify(
    {
        logger:true
    }
)
async function routes (app, options) {
    app.get('/hi', async (request, reply) => {
      return { hello: 'hi' }
    })
  }

  app.register(routes)
app.get('/', async (request, reply) => {
    return { hello: 'world' }
  })
app.get("/api", (req, res) => {
  res.send(`Hey ${req.query.name} ${req.query.name}`)
})

const start = async () => {
    try {
      await app.listen({ port: 3000 })
    } catch (err) {
        app.log.error(err)
      process.exit(1)
    }
  }
  start()

const opts = {
  schema: {
    body: {
      type: 'object',
      properties: {
        someKey: { type: 'string' },
        someOtherKey: { type: 'number' }
      }
    }
  }
}

fastify.post('/', opts, async (request, reply) => {
  return { hello: 'world' }
})
const opts = {
  schema: {
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  }
}

fastify.get('/', opts, async (request, reply) => {
  return { hello: 'world' }
})

var ws = new WebSocket("wss://echo.websocket.org");

ws.onopen = function(evt) { 
  console.log("Connection open ..."); 
  ws.send("Hello WebSockets!");
};

ws.onmessage = function(evt) {
  console.log( "Received Message: " + evt.data);
  ws.close();
};

ws.onclose = function(evt) {
  console.log("Connection closed.");
}; 

// 导入WebSocket模块:
const WebSocket = require('ws');

// 引用Server类:
const WebSocketServer = WebSocket.Server;

// 实例化:
const wss = new WebSocketServer({
    port: 3000
});
wss.on('connection', function (ws) {
    console.log(`[SERVER] connection()`);
    ws.on('message', function (message) {
        console.log(`[SERVER] Received: ${message}`);
        ws.send(`ECHO: ${message}`, (err) => {
            if (err) {
                console.log(`[SERVER] error: ${err}`);
            }
        });
    })
});

let ws = new WebSocket('ws://localhost:3000/test');

// 打开WebSocket连接后立刻发送一条消息:
ws.on('open', function () {
    console.log(`[CLIENT] open()`);
    ws.send('Hello!');
});

// 响应收到的消息:
ws.on('message', function (message) {
    console.log(`[CLIENT] Received: ${message}`);
}

// 服务端
const { createServer } = require("http");
const { Server } = require("socket.io");
const httpServer = createServer();
const io = new Server(httpServer, {
  cors: {
    origin: "*",
    credentials: true,
  },
});
io.on("connection", (socket) => {
  socket.on("message", (data) => {
    console.log("Received message:", data);
    io.emit("message", data); // 广播消息给所有客户端
  });
  socket.on("event", (data) => {
    console.log("receive:", data);
  });
  socket.on("disconnect", () => {
    console.log("disconnet");
  });
});
httpServer.listen(3000, () => {
  console.log("Server started on port 3000");
});

// 获取某个namespace(跟某个路由类似)下连接的客户端的数量
const socketCount = io.of("/").sockets.size;
console.log("Connected clients:", socketCount);

const socket = io(); // or io("/"), the main namespace
const orderSocket = io("/orders"); // the "orders" namespace
const userSocket = io("/users"); // the "users" namespace

const socket = io("https://example.com"); // or io("https://example.com/"), the main namespace
const orderSocket = io("https://example.com/orders"); // the "orders" namespace
const userSocket = io("https://example.com/users"); // the "users" namespace

// 配置cors
const io = new Server(httpServer, {
  cors: {
    origin: "https://example.com",
    allowedHeaders: ["my-custom-header"],
    credentials: true
  }
});

const count = io.engine.clientsCount;
// may or may not be similar to the count of Socket instances in the main namespace, depending on your usage
const count2 = io.of("/").sockets.size;

// make all Socket instances join the "room1" room
io.socketsJoin("room1");

// make all Socket instances in the "room1" room join the "room2" and "room3" rooms
io.in("room1").socketsJoin(["room2", "room3"]);

// make all Socket instances in the "room1" room of the "admin" namespace join the "room2" room
io.of("/admin").in("room1").socketsJoin("room2");

// this also works with a single socket ID
io.in(theSocketId).socketsJoin("room1");

// make all Socket instances leave the "room1" room
io.socketsLeave("room1");

// make all Socket instances in the "room1" room leave the "room2" and "room3" rooms
io.in("room1").socketsLeave(["room2", "room3"]);

// make all Socket instances in the "room1" room of the "admin" namespace leave the "room2" room
io.of("/admin").in("room1").socketsLeave("room2");

// this also works with a single socket ID
io.in(theSocketId).socketsLeave("room1");

// make all Socket instances disconnect
io.disconnectSockets();

// make all Socket instances in the "room1" room disconnect (and discard the low-level connection)
io.in("room1").disconnectSockets(true);

// make all Socket instances in the "room1" room of the "admin" namespace disconnect
io.of("/admin").in("room1").disconnectSockets();

// this also works with a single socket ID
io.of("/admin").in(theSocketId).disconnectSockets();

// return all Socket instances of the main namespace
const sockets = await io.fetchSockets();

// return all Socket instances in the "room1" room of the main namespace
const sockets = await io.in("room1").fetchSockets();

// return all Socket instances in the "room1" room of the "admin" namespace
const sockets = await io.of("/admin").in("room1").fetchSockets();

// this also works with a single socket ID
const sockets = await io.in(theSocketId).fetchSockets();

{
  headers: /* the headers of the initial request */
  query: /* the query params of the initial request */
  auth: /* the authentication payload */
  time: /* the date of creation (as string) */
  issued: /* the date of creation (unix timestamp) */
  url: /* the request URL string */
  address: /* the ip of the client */
  xdomain: /* whether the connection is cross-domain */
  secure: /* whether the connection is secure */
}
io.on("connection", (socket) => {
  console.log(socket.rooms); // Set { <socket.id> }
  socket.join("room1");
  console.log(socket.rooms); // Set { <socket.id>, "room1" }
});
// server A
io.on("connection", (socket) => {
  socket.data.username = "alice";
});

// server B
const sockets = await io.fetchSockets();
console.log(sockets[0].data.username); // "alice"

const socket = io("http://localhost:3000");
  socket.on("connect", () => {
    console.log("Connected to server");
  });

  socket.on("message", (data) => {
    console.log("Received message:", data);
  });

  function sendMessage() {
    const input = document.getElementById("message-input");
    const message = input.value;
    socket.emit("message", message);
    input.value = "";
  }