import { PrismaService } from "../common/prisma/prisma.service";
import { Injectable } from "@nestjs/common";
import {
  CompliancePolicyDto,
  UpdateCompliancePolicyDto,
} from "./dto/policy.dto";
import { CompliancePolicy } from "./entities/policy.entity";
import {
  CompliancePolicySource,
  ComplianceStatus,
} from "./entities/compliance.types";
import { UserService } from "../iam";
import { ComplianceEvents } from "./compliance.events";
import { getUuidSlug } from "../common/helper";
import { Prisma } from "@prisma/client";
import { TemporalProvider } from "../providers/temporal/temporal.provider";

@Injectable()
export class CompliancePolicyService {
  constructor(
    private readonly prismaService: PrismaService,
    private readonly userService: UserService,
    private readonly temporalProvider: TemporalProvider,
  ) {}

  private readonly COMPLIANCE_POLICY_UPDATE_WORKFLOW =
    "compliancePolicyUpdateWorkflow";

  /**
   * Create a new compliance policy and associated rules
   * @param {CompliancePolicyDto} compliancePolicy policy to create
   * @returns {Promise<CompliancePolicy>} created policy
   */
  async createCompliancePolicy(
    compliancePolicy: CompliancePolicyDto,
    userId: string,
  ): Promise<CompliancePolicy> {
    const _createCompliancePolicy = async (tx) => {
      const _policy = await tx.compliancePolicy.create({
        data: {
          name: compliancePolicy.name,
          description: compliancePolicy.description,
          jurisdiction: compliancePolicy.jurisdiction,
          source: compliancePolicy.source,
          createdBy: userId,
          rules: {
            connect: compliancePolicy.controls.map((rule) => ({ id: rule.id })),
          },
        },
      });

      return _policy;
    };
    const policy = await this.prismaService.$transaction(
      _createCompliancePolicy,
    );

    return new CompliancePolicy(policy);
  }

  /**
   * Get policies based on source and jurisdictions
   * @param source Source of the policy
   * @param jurisdictions List of jurisdictions
   * @returns {Promise<CompliancePolicy[]>} list of compliance policies
   */
  async getPolicies(
    source: CompliancePolicySource,
    jurisdictions: string[],
  ): Promise<CompliancePolicy[]> {
    const query = {
      source: source,
      status: {
        not: { equals: ComplianceStatus.DELETED },
      },
    };

    if (jurisdictions && jurisdictions.length > 0) {
      query["jurisdiction"] = {
        in: jurisdictions,
      };
    }

    const policies = await this.prismaService.compliancePolicy.findMany({
      where: {
        AND: {
          ...query,
        },
      },
      include: { rules: true },
    });

    return policies.map((policy) => new CompliancePolicy(policy));
  }

  /**
   * Find all compliance policies
   * @returns {Promise<CompliancePolicy[]>} list of compliance policies
   */
  async findAll(
    where?: Prisma.CompliancePolicyWhereInput,
  ): Promise<CompliancePolicy[]> {
    const policies = await this.prismaService.compliancePolicy.findMany({
      where: {
        AND: {
          ...where,
          status: {
            not: { equals: ComplianceStatus.DELETED },
          },
        },
      },
      include: { rules: true },
    });
    return policies.map((policy) => new CompliancePolicy(policy));
  }

  /**
   * Find a compliance policy by id
   * @param id policy id
   * @returns {Promise<CompliancePolicy>} compliance policy
   */
  async findOne(id: number): Promise<CompliancePolicy> {
    const policy = await this.prismaService.compliancePolicy.findUnique({
      where: { id: id },
      include: { rules: true },
    });

    return new CompliancePolicy(policy);
  }

  /**
   * Update a compliance policy and associated rules
   * @param {number} id policy id
   * @param {UpdateCompliancePolicyDto}
   * @returns {Promise<CompliancePolicy>}
   */
  async updateCompliancePolicy(
    id: number,
    compliancePolicy: UpdateCompliancePolicyDto,
    userId: string,
  ): Promise<CompliancePolicy> {
    const originalPolicy = await this.findOne(id);

    const _updateCompliancePolicy = async (tx) => {
      return await tx.compliancePolicy.update({
        where: { id: id },
        data: {
          name: compliancePolicy.name,
          description: compliancePolicy.description,
          jurisdiction: compliancePolicy.jurisdiction,
          source: compliancePolicy.source,
          rules: {
            set: compliancePolicy.controls.map((rule) => ({ id: rule.id })),
          },
        },
        include: {
          rules: true,
        },
      });
    };
    const policy = await this.prismaService.$transaction(
      _updateCompliancePolicy,
    );

    const updatedPolicy = new CompliancePolicy(policy);

    const [updatedBy, owner] = await Promise.all([
      this.userService.getUserDetails(userId),
      this.userService.getUserDetails(updatedPolicy.createdBy),
    ]);

    this.temporalProvider.runAsync(
      this.COMPLIANCE_POLICY_UPDATE_WORKFLOW,
      [
        ComplianceEvents.COMPLIANCE_UPDATE_POLICY,
        originalPolicy,
        updatedPolicy,
        updatedBy,
        owner,
      ],
      process.env.DEFAULT_QUEUE_NAME,
      `workflow-${this.COMPLIANCE_POLICY_UPDATE_WORKFLOW}-${getUuidSlug()}`,
    );

    return updatedPolicy;
  }

  /**
   * Delete a compliance policy and associated rules
   * @param {number} id policy id
   * @returns {Promise<CompliancePolicy>} deleted policy
   */
  async deleteCompliancePolicy(id: number): Promise<CompliancePolicy> {
    return await this.prismaService.compliancePolicy.update({
      where: { id: id },
      data: {
        status: ComplianceStatus.DELETED,
      },
      include: {
        rules: true,
      },
    });
  }
}