import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';

import { PrismaService } from '../_prisma/prisma.service';
import { breakdownArn } from '../util/breakdown-arn';
import { KmsKey } from './kms-key.entity';
import { KmsAlias } from './kms-alias.entity';
import { AwsProperties } from '../abstract-action.handler';
import { NotFoundException } from '../aws-shared-entities/aws-exceptions';
import { RequestContext } from '../_context/request.context';

@Injectable()
export class KmsService {
  constructor(private readonly prismaService: PrismaService) {}

  async findOneByRef(ref: string, awsProperties: AwsProperties): Promise<KmsKey> {
    if (ref.startsWith('arn')) {
      return await this.findOneByArn(ref);
    }
    return await this.findOneById(awsProperties.accountId, awsProperties.region, ref);
  }

  async findOneByArn(arn: string): Promise<KmsKey> {
    const parts = breakdownArn(arn);
    return await this.findOneById(parts.accountId, parts.region, parts.identifier.split('/')[1]);
  }

  async findOneById(accountId: string, region: string, ref: string): Promise<KmsKey> {
    const [alias, record] = await Promise.all([
      this.prismaService.kmsAlias.findFirst({
        include: {
          kmsKey: true,
        },
        where: {
          accountId,
          region,
          name: ref,
        },
      }),
      this.prismaService.kmsKey.findFirst({
        where: {
          accountId,
          region,
          id: ref,
        },
      }),
    ]);

    if (!alias?.kmsKey && !record) {
      throw new NotFoundException();
    }

    return record ? new KmsKey(record) : new KmsKey(alias!.kmsKey);
  }

  async findAndCountAliasesByKeyId(accountId: string, region: string, limit: number, kmsKeyId: string, marker = ''): Promise<KmsAlias[]> {
    const take = limit + 1;
    const records = await this.prismaService.kmsAlias.findMany({
      where: {
        accountId,
        region,
        kmsKeyId,
        name: {
          gte: marker,
        },
      },
      take,
      orderBy: {
        name: 'desc',
      },
    });

    return records.map(r => new KmsAlias(r));
  }

  async findAndCountAliases(accountId: string, region: string, limit: number, marker = ''): Promise<KmsAlias[]> {
    const take = limit + 1;
    const records = await this.prismaService.kmsAlias.findMany({
      where: {
        accountId,
        region,
        name: {
          gte: marker,
        },
      },
      take,
      orderBy: {
        name: 'desc',
      },
    });

    return records.map(r => new KmsAlias(r));
  }

  async createKmsKey(data: Prisma.KmsKeyCreateInput): Promise<KmsKey> {
    const record = await this.prismaService.kmsKey.create({
      data,
    });
    return new KmsKey(record);
  }

  async updateKmsKey(id: string, data: Prisma.KmsKeyUpdateInput): Promise<void> {
    await this.prismaService.kmsKey.update({
      where: { id },
      data,
    });
  }

  async createAlias(data: Prisma.KmsAliasCreateInput) {
    await this.prismaService.kmsAlias.create({
      data,
    });
  }

  async findAliasByName(accountId: string, region: string, name: string): Promise<KmsAlias | null> {
    const record = await this.prismaService.kmsAlias.findUnique({
      where: {
        accountId_region_name: {
          accountId,
          region,
          name,
        },
      },
    });

    return record ? new KmsAlias(record) : null;
  }

  async deleteAlias(accountId: string, region: string, name: string): Promise<void> {
    await this.prismaService.kmsAlias.delete({
      where: {
        accountId_region_name: {
          accountId,
          region,
          name,
        },
      },
    });
  }
}