import { PrismaService } from "../common/prisma/prisma.service";
import { Injectable } from "@nestjs/common";
import { ComplianceRule } from "./entities/rule.entity";
import { ComplianceStatus } from "./entities/compliance.types";
import { ComplianceRuleDto, UpdateComplianceRuleDto } from "./dto/rule.dto";
import { UserService } from "../iam";
import { ComplianceEvents } from "./compliance.events";
import { getUuidSlug } from "../common/helper";
import { TemporalProvider } from "../providers/temporal/temporal.provider";

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

  private readonly COMPLIANCE_RULE_UPDATE_WORKFLOW =
    "complianceRuleUpdateWorkflow";

  /**
   * Find all compliance rules for a given policy
   * @param {number} policyId policy id
   * @returns {Promise<ComplianceRule[]>} list of compliance rules
   */
  async findForPolicy(policyId: number): Promise<ComplianceRule[]> {
    return this.findMany({ policyIds: [policyId] });
  }

  /**
   * Find a compliance rule by id
   * @param {number} id rule id
   * @returns {Promise<ComplianceRule>} compliance rule
   */
  async findOne(id: number): Promise<ComplianceRule> {
    const rule = await this.prismaService.complianceRule.findUnique({
      where: { id: id },
    });

    return new ComplianceRule(rule);
  }

  /**
   * Create a new compliance rule
   * @param {ComplianceRuleDto} rule rule data
   * @param {string} userId user id
   * @returns {Promise<ComplianceRule>} created rule
   */
  async createComplianceRule(
    rule: ComplianceRuleDto,
    userId: string,
  ): Promise<ComplianceRule> {
    return new ComplianceRule(
      await this.prismaService.complianceRule.create({
        data: { ...rule, createdBy: userId },
      }),
    );
  }

  /**
   * Update a compliance rule
   * @param {UpdateComplianceRuleDto} complianceRule rule data to update
   * @returns {Promise<ComplianceRule>} updated rule
   */
  async updateComplianceRule(
    id: number,
    complianceRule: UpdateComplianceRuleDto,
    userId: string,
  ): Promise<ComplianceRule> {
    const originalRule = await this.prismaService.complianceRule.findUnique({
      where: { id: id },
      include: { policies: true, risks: true },
    });

    const updatedRule = new ComplianceRule(
      await this.prismaService.complianceRule.update({
        where: { id: id },
        data: complianceRule,
      }),
    );

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

    this.temporalProvider.runAsync(
      this.COMPLIANCE_RULE_UPDATE_WORKFLOW,
      [
        ComplianceEvents.COMPLIANCE_UPDATE_RULE,
        originalRule,
        updatedRule,
        complianceRule,
        updatedBy,
        owner,
      ],
      process.env.DEFAULT_QUEUE_NAME,
      `workflow-${this.COMPLIANCE_RULE_UPDATE_WORKFLOW}-${getUuidSlug()}`,
    );

    return updatedRule;
  }

  /**
   * Delete a compliance rule
   * @param {number} id rule id
   * @returns {Promise<ComplianceRule>} deleted rule
   */
  async deleteRule(id: number): Promise<ComplianceRule> {
    const rule = await this.prismaService.complianceRule.update({
      where: { id: id },
      data: { status: ComplianceStatus.DELETED },
    });

    return new ComplianceRule(rule);
  }

  /**
   * Find compliance rules based on query
   * @param {object} query query object
   * @returns {Promise<ComplianceRule[]>} list of compliance rules
   */
  async findMany(query: {
    policyIds?: number[];
    category?: string;
    severity?: string;
    status?: string;
    ids?: number[];
  }): Promise<ComplianceRule[]> {
    const whereClause = {};
    if (query.policyIds) {
      whereClause["policies"] = {
        some: {
          id: {
            in: query.policyIds,
          },
        },
      };
    }

    if (query.category) {
      whereClause["category"] = query.category;
    }

    if (query.severity) {
      whereClause["severity"] = query.severity;
    }

    if (query.status) {
      whereClause["status"] = query.status;
    } else {
      whereClause["status"] = {
        not: { equals: ComplianceStatus.DELETED },
      };
    }

    if (query.ids) {
      whereClause["id"] = {
        in: query.ids,
      };
    }

    if (Object.keys(whereClause).length === 0) {
      return [];
    }
    const rules = await this.prismaService.complianceRule.findMany({
      where: whereClause,
    });

    return rules.map((rule) => new ComplianceRule(rule));
  }

  /**
   * Find all compliance rules
   * @returns {Promise<ComplianceRule[]>} list of compliance rules
   */
  async findAll(): Promise<ComplianceRule[]> {
    const rules = await this.prismaService.complianceRule.findMany({
      where: {
        status: {
          not: { equals: ComplianceStatus.DELETED },
        },
      },
    });

    return rules.map((rule) => new ComplianceRule(rule));
  }
}