import { refresh } from "./api/auth";
import app from "./api/server";
import {
  engine,
  PORT,
  prisma,
  unifi,
  unifiPassword,
  unifiUsername,
} from "./constants";
import { unifiSites } from "./managers/unifiSites";
import { refreshCompanies } from "./modules/cw-utils/refreshCompanies";
import { refreshCatalog } from "./modules/cw-utils/procurement/refreshCatalog";
import { refreshInventory } from "./modules/cw-utils/procurement/refreshInventory";
import { refreshOpportunities } from "./modules/cw-utils/opportunities/refreshOpportunities";
import { events, setupEventDebugger } from "./modules/globalEvents";
import { signPermissions } from "./modules/permission-utils/signPermissions";
import { RoleController } from "./controllers/RoleController";
import cuid from "cuid";

// Setup global event debugger in non-production environments
if (Bun.env.NODE_ENV == "development") setupEventDebugger();

// Ensure administrator role exists
const existingAdmin = await prisma.role.findFirst({
  where: { moniker: "administrator" },
  include: { users: { include: { roles: true } } },
});

if (!existingAdmin) {
  const id = cuid();
  const created = await prisma.role.create({
    data: {
      id,
      moniker: "administrator",
      title: "Admin",
      permissions: signPermissions({
        issuer: "roles",
        subject: id,
        permissions: ["*"],
      }),
    },
    include: { users: { include: { roles: true } } },
  });
  events.emit("role:created", new RoleController(created));
}

// Helper to run a startup sync safely — failures are logged but never crash the process.
const safeStartup = async (label: string, fn: () => Promise<void>) => {
  try {
    await fn();
  } catch (err) {
    console.error(
      `[startup] ${label} failed — will retry on next interval`,
      err,
    );
  }
};

// Refresh the internal list of companies every minute
await safeStartup("refreshCompanies", refreshCompanies);
setInterval(() => {
  return refreshCompanies().catch((err) =>
    console.error("[interval] refreshCompanies failed", err),
  );
}, 60 * 1000);

// Refresh the internal catalog every minute
await safeStartup("refreshCatalog", refreshCatalog);
setInterval(() => {
  return refreshCatalog().catch((err) =>
    console.error("[interval] refreshCatalog failed", err),
  );
}, 60 * 1000);

// Refresh inventory on hand every 2 minutes
await safeStartup("refreshInventory", refreshInventory);
setInterval(
  () => {
    return refreshInventory().catch((err) =>
      console.error("[interval] refreshInventory failed", err),
    );
  },
  2 * 60 * 1000,
);

// Refresh opportunities every minute
await safeStartup("refreshOpportunities", refreshOpportunities);
setInterval(() => {
  return refreshOpportunities().catch((err) =>
    console.error("[interval] refreshOpportunities failed", err),
  );
}, 60 * 1000);

await safeStartup("syncSites", () => unifiSites.syncSites());
setInterval(() => {
  return unifiSites
    .syncSites()
    .catch((err) => console.error("[interval] syncSites failed", err));
}, 60 * 1000);

Bun.serve({
  port: PORT,
  websocket: engine.handler().websocket,
  fetch: (req, server) => {
    const url = new URL(req.url);

    if (url.pathname.startsWith("/socket.io/")) {
      return engine.handleRequest(req, server as any);
    }

    return app.fetch(req, server);
  },
});