import { NestFactory } from '@nestjs/core';

import { PersistenceModule } from './persistence/persistence.module';
import { PrismaService } from './persistence/prisma.service';
import { DataMigration } from './persistence/data-migrations/data-migration.interface';
import { _00ApplicationBootstrapDataMigration } from './persistence/data-migrations';
import { CloudDav } from './domain/cloud-dav.types';
import { Identity } from './domain/identity.types';

async function bootstrap() {
  const app = await NestFactory.create(PersistenceModule);
  const prismaService = app.get(PrismaService);

  await ensureEnumIntegrity(prismaService);

  const registeredMigrations: DataMigration[] = [
    new _00ApplicationBootstrapDataMigration,
  ];
  
  const alreadyRan = await prismaService.systemPostMigration.findMany();
  const alreadyRanList = alreadyRan.map(e => e.name);
  
  for (const migration of registeredMigrations) {
    if (alreadyRanList.includes(migration.name)) {
      continue;
    }
    await migration.run(prismaService);
    await prismaService.systemPostMigration.create({ data: { name: migration.name }});
    alreadyRanList.push(migration.name);
  }
}

async function ensureEnumIntegrity(prisma: PrismaService) {

  const enumsRegistered: [string, string[]][] = [
    ['enumIdentityGroupRole', Object.values<string>(Identity.Group.Role)],
    ['enumIdentityAuthDeviceType', Object.values<string>(Identity.AuthDevice.Type)],
    ['enumCloudDavResourceType', Object.values<string>(CloudDav.Resource.Type)],
  ];

  for (const [dbRunner, known] of enumsRegistered) {
    await prisma.$transaction(async (tx) => {
      // @ts-ignore
      const result = await tx[dbRunner].findMany();
      // @ts-ignore
      const existing: string[] = result.map(e => e.enumValue);
      const missing = known.filter(k => !existing.includes(k));
      // @ts-ignore
      await tx[dbRunner].createMany({
        data: missing.map(enumValue => ({ enumValue })),
      });
    });
  }
}

bootstrap();