import { FastifyInstance } from "fastify";
import { PrismaClient } from "@prisma/client";
import * as crypto from "crypto";
import config from "../../config";
import { response400 } from "./schemas/response400";
const prisma = new PrismaClient();

module.exports = (app: FastifyInstance) => {
  app.post<{ Body: { nickname: string } }>(
    "/api/user/register",
    {
      config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: "1 minute",
        },
      },
      schema: {
        body: {
          type: "object",
          required: ["nickname"],
          properties: {
            nickname: { type: "string" },
          },
        },
        tags: ["User"],
        response: {
          200: {
            type: "object",
            properties: {
              nickname: { type: "string" },
              level: { type: "number" },
              token: { type: "string" },
            },
          },
          ...response400
        },
      },
    },
    async (request, reply) => {
      const { nickname } = request.body;
      const token = crypto
        .createHash("sha256")
        .update(nickname + Date.now())
        .digest("hex");
      //Проверяем есть ли  пользователь с таким ником
      const existUser = await prisma.user.findFirst({
        where: {
          nickname,
        },
      });
      if (existUser) {
        reply
          .status(400)
          .send({
            error: "Пользователь с таким никнеймом уже зарегестрирован",
          });
      }
      //Создаем пользователя
      const user = await prisma.user.create({
        data: {
          nickname,
          level: 1,
          token,
        },
      });

      //Создаем запись о первом уровне
      const usreLevel = await prisma.level.create({
        data: {
          userId: user.id,
          level: 1,
          shots: 0,
          miss: 0,
          score: 0,
        },
      });

      reply.status(200).send({ nickname, level: 1, token });
    }
  );
};

import { PrismaClient } from '@prisma/client';
import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
import { FastifyRequest } from 'fastify/types/request';

const prisma = new PrismaClient();

export const preValidation = async function(request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) {
    const token = request.headers["token"] as string;
    // Check if the token exists in the headers
    if (!token) {
      reply.code(401).send({ error: "Token is missing in headers" });
      done();
      return;
    }
    // Check if the token exists in the Prisma user table
    const user = await prisma.user.findUnique({
      where: {
        token: token,
      },
    });
    if (!user) {
      reply.code(401).send({ error: "Invalid token" });
      done();
      return;
    }
    request.user = user;
  };

Главное не забыть еще расширить тип FastifyRequest новыми данными

declare module 'fastify' {
  interface FastifyRequest {
    user?: {
      id: number;
      nickname: string;
      token: string;
      level: number;
    };
    rateLimit: {
      current: number;
      remaining: number;
    };
  }
}

import { FastifyInstance, FastifyRequest } from "fastify";
import path from "path";
import fs from "fs";
import config from "../../config";
module.exports = (app: FastifyInstance) => {
  app.get(
    "/api/user/level",
    {
      config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: '1 minute'
        }
      },
      schema: {
        summary: "Получить текущий уровень пользователя",
        description:
          "Возвращает PNG-изображение уровня пользователя",
        tags: ["User"],
        querystring: {
          type: "object",
          required: ["userId", "level"],
          properties: {
            userId: {
              type: "string",
              description: "ID пользователя",
            },
            level: {
              type: "string",
              description: "Номер уровня",
            },
          },
        },
        response: {
          200: {
            description: "PNG-изображение",
            headers: {
              "Content-Type": { type: "string", enum: ["image/png"] },
            },
            type: "string",
            format: "binary",
          },
          404: {
            description: "Изображение не найдено",
            type: "object",
            properties: {
              error: { type: "string" },
              message: { type: "string" },
            },
          },
          400: {
            description: "Ошибка валидации параметров",
            type: "object",
            properties: {
              error: { type: "string" },
              message: { type: "string" },
            },
          },
        },
      },
    },
    /**
     * Возвращаем изображение текущего уровня пользователю
     */
    async (
      request: FastifyRequest<{
        Querystring: { userId: string; level: string };
      }>,
      reply
    ) => {
      const { userId, level } = request.query;

      // Валидация параметров
      if (!userId || !level) {
        return reply.status(400).send({
          error: "Validation Error",
          message: "Параметры userId и level обязательны",
        });
      }

      const imageName = `${userId}-${level}.png`;
      const imagePath = path.join(__dirname, "../api/images", imageName);

      if (fs.existsSync(imagePath)) {
        return reply
          .header("Content-Type", "image/png")
          .send(fs.readFileSync(imagePath));
      } else {
        return reply.status(404).send({
          error: "Image not found",
          message: `Изображение ${imageName} не найдено`,
        });
      }
    }
  );
};

import { FastifyInstance, FastifyRequest } from "fastify";
import path from "path";
import fs from "fs";
import config from "../../config";
import { preValidation } from "./middleware/preValidation";
import { response400 } from "./schemas/response400";

module.exports = (app: FastifyInstance) => {
  app.get(
    "/api/level/source",
    {
      config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: '1 minute'
        }
      },
      preValidation,
      schema: {
        security: [{ apiToken: [] }],
        summary: "Получить изображение текущего уровня",
        description:
          "Возвращает PNG-изображение текущего уровня пользователя",
        tags: ["Level"],
        response: {
          200: {
            description: "PNG-изображение",
            headers: {
              "Content-Type": { type: "string", enum: ["image/png"] },
            },
            type: "string",
            format: "binary",
          },
          404: {
            description: "Изображение не найдено",
            type: "object",
            properties: {
              error: { type: "string" },
              message: { type: "string" },
            },
          },
          ...response400
        },
      },
    },
    /**
     * Возвращаем изображение текущего уровня пользователю
     */
    async (
      request,
      reply
    ) => {
      const imageName = `${request.user?.level}.png`;
      const imagePath = path.join(__dirname, "../../../levels", imageName);

      if (fs.existsSync(imagePath)) {
        return reply
          .header("Content-Type", "image/png")
          .send(fs.readFileSync(imagePath));
      } else {
        return reply.status(404).send({
          error: "404",
          message: `Изображение ${imagePath} не найдено`,
        });
      }
    }
  );
};

import { FastifyInstance } from "fastify";
import { PrismaClient } from "@prisma/client";
import { preValidation } from "./middleware/preValidation";
import config from "../../config";

const prisma = new PrismaClient();

// Function to generate a random color in RGB HEX format
function generateRandomColor() {
  return (
    "#" +
    Math.floor(Math.random() * 16777215)
      .toString(16)
      .padStart(6, "0")
  );
}

module.exports = (app: FastifyInstance) => {
  app.get(
    "/api/colors/generate",
    {
      config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: "1 minute",
        },
      },
      schema: {
        security: [{ apiToken: [] }],
        summary: "Генерация цветов",
        description: "Генерирует 5 случайных цветов за 1 ход",
        tags: ["Colors"],
        response: {
          200: {
            type: "object",
            properties: {
              colors: { type: "array" },
            },
          },
        },
      },
      preValidation,
    },
    async (request, reply) => {
      let user = request.user;
      if (user) {
        const userColorsCount = await prisma.color.count({
          where: { userId: +user.id },
        });
        let genColorsCount = 5;

        if (userColorsCount === config.colorsLimit) {
          reply.code(400).send({ error: "Limit colors reached" });
        }
        if (userColorsCount + 5 > config.colorsLimit) {
          genColorsCount = config.colorsLimit - userColorsCount;
        }

        // Generate random colors
        const colors = Array.from({ length: genColorsCount }, () =>
          generateRandomColor()
        );
        // Add the generated colors to the database using Prisma
        await Promise.all(
          colors.map(async (color) => {
            return prisma.color.create({
              data: {
                color,
                userId: +user.id,
              },
            });
          })
        );
        reply.code(200).send({ colors });
      } else {
        reply.code(401).send({ error: "Invalid user" });
      }
    }
  );
};

import path from "path";
import { createCanvas, loadImage } from "canvas";
import { parentPort } from "worker_threads";
import { PrismaClient } from "@prisma/client";
import config from "../config";
const prisma = new PrismaClient();

if (parentPort) {
  parentPort.on("message", async (shot: { level: number; userId: number }) => {
    console.log("message", shot);
    try {
      parentPort?.postMessage({
        success: true,
        score: await clacRate(shot.level, shot.userId),
      });
    } catch (error: any) {
      parentPort?.postMessage({
        success: false,
        error: error.message,
      });
    }
  });
}

async function clacRate(level: number, userId: number) {
  console.time("score");
  const width = config.canvasWidth,
    height = config.canvasHeight;
  let score = 0;
  const levelImage = `${userId}-${level}.png`;
  console.log("start calculate", level, userId, levelImage);
  //Prepare source image
  const sourceImage = await loadImage(
    path.join(__dirname, "../../levels", `${level}.png`)
  );
  const sourceCanvas = createCanvas(width, height);
  const sourceCtx = sourceCanvas.getContext("2d");
  sourceCtx.drawImage(sourceImage, 0, 0);
  const sourceData = sourceCtx.getImageData(0, 0, width, height);

  //Prepare level image
  const levelImg = await loadImage(
    path.join(__dirname, "/api/images", levelImage)
  );
  const levelCanvas = createCanvas(width, height);
  const levelCtx = levelCanvas.getContext("2d");
  levelCtx.drawImage(levelImg, 0, 0);
  const levelData = levelCtx.getImageData(0, 0, width, height);

  // Проверяем каждый пиксель построчно
  for (let i = 0; i < sourceData.data.length; i += 4) {
    const r = sourceData.data[i]; // Red
    const g = sourceData.data[i + 1]; // Green
    const b = sourceData.data[i + 2]; // Blue
    const a = sourceData.data[i + 3]; // Alpha
    //Пропускаем прозрачные пиксели
    if (a === 0) {
      continue;
    }
    const lr = levelData.data[i]; // Red
    const lg = levelData.data[i + 1]; // Green
    const lb = levelData.data[i + 2]; // Blue
    const la = levelData.data[i + 3]; // Alpha

    //Skip white and transparent pixels
    if (
      a > 0 &&
      r < 255 &&
      g < 255 &&
      b < 255 &&
      la > 0 &&
      lr < 255 &&
      lg < 255 &&
      lb < 255
    ) {
      //Debug info
      score += 765 - (r - lr + (g - lg) + (b - lb));
    }
  }
  console.log("score", Math.round(score));
  score = Number(score / 1000);
  console.timeEnd("score");
  //Обновляем информацию в БД
  const currentLevel = await prisma.level.findFirst({
    where: {
      userId,
      level,
    },
  });

  if (currentLevel) {
    await prisma.level.update({
      where: {
        id: currentLevel.id,
      },
      data: {
        score: score
      }
    });
  }
  return score;
}

import { FastifyInstance } from "fastify";
import { PrismaClient } from "@prisma/client";
import { preValidation } from "./middleware/preValidation";
import config from "../../config";
const prisma = new PrismaClient();

module.exports = (app: FastifyInstance) => {
  app.get<{ Body: { nickname: string } }>(
    "/api/level/next",
    {
      config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: "1 minute",
        },
      },
      schema: {
        security: [{ apiToken: [] }],
        tags: ["Level"],
        summary: "Переключиться на следующий уровень",
        description: "После вызова, пользователю становится доступен следующий уровень, действие нельзя отменить",
        response: {
          200: {
            type: "object",
            properties: {
              level: { type: "number" },
            },
          },
        },
      },
      preValidation,
    },
    async (request, reply) => {
      if (request.user) {
        const currentLevel = request.user?.level;
        let newLevel = currentLevel;
        console.log("currentLevelt", currentLevel, "maxlbl", config.levels);
        if (config.levels > currentLevel) {
          newLevel = currentLevel + 1;
        }
        //Переводим пользователя на новый уровень
        await prisma.user.update({
          where: { id: request.user.id },
          data: {
            level: newLevel,
          },
        });
        //Создаем запись про новый уровень
        const userLevel = await prisma.level.create({
          data: {
            userId: request.user.id,
            level: newLevel,
            shots: 0,
            miss: 0,
            score: 0,
          },
        });
        reply.status(200).send({ level: newLevel });
      } else {
        reply.status(401).send({ error: "Invalid user" });
      }
    }
  );
};

import { FastifyInstance } from 'fastify';
import { PrismaClient } from '@prisma/client';
import config from '../../config';

const prisma = new PrismaClient();

module.exports = function (app: FastifyInstance) {
  app.get('/api/game/results', {
    config: {
        rateLimit: {
          max: config.maxRPM,
          timeWindow: "1 minute",
        },
      },
    schema: {
      summary: "Получение результатов игроков",
      description: "Возвращает результаты игроков, сгруппированные по userId и отсортированные по общему score",
      tags: ["Game"],
      querystring: {
        type: 'object',
        properties: {
          order: { 
            type: 'string',
            enum: ['asc', 'desc'],
            default: 'desc'
          }
        }
      },
      response: {
        200: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              userId: { type: 'number' },
              totalScore: { type: 'number' },
              nickname: { type: 'string' },
              levels: {
                type: 'array',
                items: {
                  type: 'object',
                  properties: {
                    id: { type: 'number' },
                    level: { type: 'number' },
                    score: { type: 'number' },
                    miss: { type: 'number' },
                    shots: { type: 'number' }
                  }
                }
              }
            }
          }
        }
      }
    }
  }, async (request, reply) => {
    const { order = 'desc' } = request.query as { order?: 'asc' | 'desc' };

    const usersWithLevels = await prisma.user.findMany({
      select: {
        id: true,
        nickname: true,
        levels: {
          select: {
            id: true,
            level: true,
            score: true,
            miss: true,
            shots: true
          }
        }
      }
    });

    const results = usersWithLevels
      .map((user) => {
        const totalScore = user.levels.reduce((sum, level) => sum + level.score, 0);
        return {
          userId: user.id,
          nickname: user.nickname,
          totalScore,
          levels: user.levels
        };
      })
      .sort((a, b) => order === 'desc' ? b.totalScore - a.totalScore : a.totalScore - b.totalScore);

    return reply.send(results);
  });
}