import { Elysia } from "elysia";
import { AuthSession, authSessions } from "../db/schema/authSessions";
import { eq, isNull, and } from "drizzle-orm";
import db from "../db";
import { jwtVerify } from "jose";
import { userService } from "../services/auth/user";
import { protectedRoutes } from "../db/schema";
import { RoleName } from "../services/auth";

// JWT секрет (должен совпадать с session.service.ts)
const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET);

export const authMiddleware = new Elysia().derive(
  { as: "scoped" },
  async ({ request, status }) => {
    const { headers } = request;
    const authHeader = headers.get("Authorization");

    // 1. Проверить наличие заголовка Authorization
    if (!authHeader || !authHeader.startsWith("Bearer ")) {
      return status(401, "Missing or invalid authorization header");
    }

    const accessToken = authHeader.split(" ")[1];

    if (!accessToken) {
      return status(401, "Missing access token");
    }

    // 2. Верифицировать JWT (проверка подписи и срока действия)
    let sessionId: string;

    try {
      const { payload } = await jwtVerify<{ id: string }>(
        accessToken,
        JWT_SECRET
      );

      sessionId = payload.id;

      if (!sessionId) {
        return status(401, "Invalid token payload");
      }
    } catch (err) {
      return status(401, "Invalid or expired token");
    }

    // 3. Получить сессию из БД и проверить её валидность
    let authSession: AuthSession;

    try {
      authSession = (
        await db
          .select()
          .from(authSessions)
          .where(
            and(
              eq(authSessions.id, sessionId),
              isNull(authSessions.revokedAt) // Сессия не отозвана
            )
          )
          .limit(1)
      )[0];

      if (!authSession) {
        return status(401, "Session not found or revoked");
      }
    } catch (err) {
      // Ошибка БД - 500, а не 401
      console.error("Database error in auth middleware:", err);
      return status(500, "Internal server error");
    }

    // 4. Проверить срок действия сессии
    if (authSession.expiresAt && authSession.expiresAt < new Date()) {
      return status(401, "Session expired");
    }

    // 5. Верифицировать bcrypt hash токена
    try {
      const verified = await Bun.password.verify(
        accessToken,
        authSession.accessTokenHash
      );

      if (!verified) {
        return status(401, "Invalid token hash");
      }
    } catch (err) {
      console.error("Token verification error:", err);
      return status(500, "Internal server error");
    }

    // 6. Получить пользователя
    const user = await userService.findById(authSession.userId);

    if (!user) {
      return status(401, "User not found");
    }

    // 7. Проверить доступ к маршруту на основе ролей (если маршрут защищен)
    const url = new URL(request.url);
    const path = url.pathname;
    const method = request.method;

    // Получить маршрут из БД
    const route = await db
      .select({
        methods: protectedRoutes.methods,
        roles: protectedRoutes.roles,
      })
      .from(protectedRoutes)
      .where(eq(protectedRoutes.path, path))
      .limit(1);

    // Если маршрут защищен, проверить права доступа
    if (route.length > 0) {
      const allowedMethods = route[0].methods;
      const allowedRoles = route[0].roles;

      // Проверить, что метод входит в список разрешенных
      if (allowedMethods.includes(method)) {
        // Проверить, есть ли роль пользователя среди разрешенных
        if (!allowedRoles.includes(user.role as RoleName)) {
          return status(403, "Access denied: insufficient permissions");
        }
      }
    }

    // 8. Всё ОК - вернуть сессию и санитизированного пользователя (без пароля)
    return {
      authSession,
      currentUser: userService.sanitize(user),
    };
  }
);
