import { createAssetModule } from "@metis/assets/module";
import { createCompanyModule } from "@metis/companies/module";
import {
  SequelizeSessionStore,
  createIdentityModule,
  migrateIdentity,
} from "@metis/identity/module";
import { createResourceModule } from "@metis/resources/module";
import session from "express-session";
import type { Sequelize } from "sequelize";

import type { readDatabaseEnvironment } from "../../config/database";

import { registerDirectoryRelationshipRoutes } from "./directory-relationship.routes";
import { createRelationshipRuntime } from "./relationship-runtime";

export async function createIdentityRuntime(
  database: Sequelize,
  environment: ReturnType<typeof readDatabaseEnvironment>,
  options: { legacyResourceFixtures?: boolean } = {}
) {
  await database.authenticate();
  await migrateIdentity(database);
  const identity = await createIdentityModule(database, environment.APP_ORIGIN);
  const companies = await createCompanyModule(
    database,
    identity.authenticate,
    options.legacyResourceFixtures === true && environment.NODE_ENV === "test"
  );
  const resources = await createResourceModule(
    database,
    identity.authenticate,
    companies.directoryContexts,
    companies.resourceAccess,
    identity.requireGlobalResourceManager,
    {
      catalogEnabled: environment.RESOURCE_GLOBAL_CATALOG_ENABLED,
      softwareEnabled: environment.RESOURCE_GLOBAL_SOFTWARE_ENABLED,
      profileEnabled: environment.RESOURCE_GLOBAL_PROFILE_ENABLED,
      softwareCandidatesEnabled: environment.RESOURCE_GLOBAL_SOFTWARE_CANDIDATES_ENABLED,
      canManage: async (context) =>
        (await identity.services.authorization.canManageGlobalResources(context)).isSuccess,
    }
  );
  const assets = await createAssetModule(
    database,
    identity.authenticate,
    resources.services.directoryDomains,
    resources.services.networkShares
  );
  const localIdentities = await companies.initializeLocalIdentities(
    assets.services.localIdentities
  );
  const relationships = createRelationshipRuntime(identity, companies, assets, resources);
  const mail = await companies.initializeMail(assets.services.inventory);
  const profiles = await companies.initializeProfiles(
    assets.services.inventory,
    resources.services.inventory,
    {
      references: resources.services.applicationReferences,
      resources: resources.services.inventoryForTransaction,
      assets: assets.services.inventoryForTransaction,
    }
  );

  await resources.migrateLegacy();
  const dashboard = companies.initializeDashboard(
    assets.services.dashboard,
    resources.services.dashboard
  );
  const store = new SequelizeSessionStore(database);
  const middleware = session({
    name: "metis.sid",
    secret: environment.SESSION_SECRET,
    store,
    resave: false,
    saveUninitialized: false,
    cookie: {
      httpOnly: true,
      sameSite: "strict",
      secure: environment.NODE_ENV === "production",
      maxAge: 8 * 60 * 60 * 1000,
    },
  });

  return {
    relationships,
    register: (app: Parameters<typeof identity.register>[0]) => {
      identity.register(app);
      companies.register(app);
      localIdentities.register(app);
      registerDirectoryRelationshipRoutes(app, relationships, identity.authenticate);
      assets.register(app);
      resources.register(app);
      mail.register(app);
      profiles.register(app);
      dashboard.register(app);
    },
    middleware,
    // El almacén relacional no utiliza un temporizador de fondo.
    stop: () => undefined,
  };
}