import {
  Body,
  Controller,
  Delete,
  Get,
  HttpException,
  HttpStatus,
  MaxFileSizeValidator,
  Param,
  ParseFilePipe,
  ParseIntPipe,
  Post,
  Query,
  Request,
  Res,
  UnauthorizedException,
  UploadedFile,
  UseInterceptors,
} from "@nestjs/common";
import { Response } from "express";
import { ComplianceService } from "./compliance.service";
import { ComplianceSubmissionDto } from "./dto/submission.dto";
import {
  COMPLIANCE_EVIDENCE_SUBMIT_ACTION,
  COMPLIANCE_JURISDICTIONS,
  COMPLIANCE_POLICY_CREATE_ACTION,
  COMPLIANCE_POLICY_DELETE_ACTION,
  COMPLIANCE_POLICY_READ_ACTION,
  COMPLIANCE_POLICY_UPDATE_ACTION,
  COMPLIANCE_RESOURCE_NAME,
  COMPLIANCE_RISK_READ_ACTION,
  COMPLIANCE_RISK_SUBMIT_ACTION,
  COMPLIANCE_RISK_UPDATE_ACTION,
  COMPLIANCE_RULE_CREATE_ACTION,
  COMPLIANCE_RULE_DELETE_ACTION,
  COMPLIANCE_RULE_READ_ACTION,
  COMPLIANCE_RULE_UPDATE_ACTION,
  COMPLIANCE_SETTINGS_READ_ACTION,
  COMPLIANCE_SUBMIT_ACTION,
  Jurisdiction,
} from "./compliance.constants";
import { ComplianceRiskService } from "./risk.service";
import { PolicyService } from "../iam";
import { CompliancePolicyService } from "./policy.service";
import { EvidenceService } from "./evidence.service";
import { ComplianceEvidenceDto } from "./dto/evidence.dto";
import { ComplianceRiskSubmissionDto } from "./dto/risk.submission.dto";
import { FileInterceptor } from "@nestjs/platform-express";
import { ApiBearerAuth, ApiBody, ApiConsumes } from "@nestjs/swagger";
import { MinioProvider } from "../providers/minio/minio.provider";
import { ProjectService } from "../project/project.service";
import { ComplianceRuleDto, UpdateComplianceRuleDto } from "./dto/rule.dto";
import { ComplianceRuleService } from "./rule.service";
import { ComplianceRule } from "./entities/rule.entity";
import {
  CompliancePolicyDto,
  UpdateCompliancePolicyDto,
} from "./dto/policy.dto";
import { CompliancePolicy } from "./entities/policy.entity";
import { CompliancePolicySource } from "./entities/compliance.types";
import { FileExtensionValidator } from "../common/validators/extension.validator";

@ApiBearerAuth("access-token")
@Controller("compliance")
export class ComplianceController {
  constructor(
    private readonly policyService: PolicyService,
    private readonly complianceService: ComplianceService,
    private readonly ruleService: ComplianceRuleService,
    private readonly compliancePolicyService: CompliancePolicyService,
    private readonly riskService: ComplianceRiskService,
    private readonly evidenceService: EvidenceService,
    private readonly storageProvider: MinioProvider,
    private readonly projectService: ProjectService,
  ) {}

  @Get("/hasSubmitPermission")
  canSubmitCompliance(
    @Query("projectId", new ParseIntPipe()) projectId: number,
    @Request() request,
  ) {
    return this.policyService.checkPermission(
      request.user.permission,
      projectId,
      COMPLIANCE_RESOURCE_NAME,
      COMPLIANCE_SUBMIT_ACTION,
    );
  }

  /**
   * Function to check if the user has permission to view compliance settings
   * compliance settings are the settings for compliance controls and policies
   * i.e policy center in the UI
   * @param request
   * @returns boolean
   */
  @Get("canViewComplianceSettings")
  canViewSettings(@Request() request): boolean {
    return this.policyService.checkPermission(
      request.user.permission,
      0,
      COMPLIANCE_RESOURCE_NAME,
      COMPLIANCE_SETTINGS_READ_ACTION,
    );
  }

  @Post("submit")
  async submitCompliance(
    @Body() submission: ComplianceSubmissionDto,
    @Request() request,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        submission.projectId,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_SUBMIT_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.complianceService.submitCompliance(submission, request.user.id);
  }

  @Get("frameworks")
  async getFrameworks(@Request() request,) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.compliancePolicyService.findAll({
      source: CompliancePolicySource.EXTERNAL,
    });
  }

  @Get("jurisdictions")
  getJurisdictions() {
    return COMPLIANCE_JURISDICTIONS;
  }

  @Get("project/:projectId/users")
  getComplianceUsers(
    @Param("projectId", new ParseIntPipe()) projectId: number,
  ) {
    return this.complianceService.getComplianceUsers(+projectId);
  }

  @Post("/risk/submit")
  async submitComplianceRisk(
    @Body() submissionData: ComplianceRiskSubmissionDto,
    @Request() request,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        submissionData.projectId,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RISK_SUBMIT_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.riskService.submitComplianceRisk(
      submissionData,
      request.user.id,
    );
  }

  @Get("/risk/submission/:riskSubmissionId")
  async fetchRiskSubmission(
    @Param("riskSubmissionId", new ParseIntPipe()) riskSubmissionId: number,
    @Request() request,
    @Query("projectId", new ParseIntPipe()) projectId: number,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        projectId,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RISK_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.riskService.findRiskSubmission(riskSubmissionId);
  }

  @Post("risk/:riskId/assign")
  async assignRisk(
    @Param("riskId", new ParseIntPipe()) riskId: number,
    @Request() request,
    @Body("userId") userId: string,
  ) {
    const risk = await this.riskService.findOne(riskId);

    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        risk.project["id"],
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RISK_UPDATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.riskService.assignRiskToUser(riskId, userId, request.user.id);
  }

  @Get("/risks")
  async getComplianceRisks(
    @Query("projectId", new ParseIntPipe()) projectId: number,
    @Request() request,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        projectId,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RISK_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.riskService.findForProject(projectId);
  }

  @Post("/evidence")
  @UseInterceptors(FileInterceptor("file"))
  @ApiConsumes("multipart/form-data")
  @ApiBody({
    type: "multipart/form-data",
    required: true,
    schema: {
      type: "object",
      properties: {
        file: {
          type: "string",
          format: "binary",
        },
        name: {
          type: "string",
          format: "string",
        },
        description: {
          type: "string",
          format: "string",
        },
        projectId: {
          type: "number",
          format: "number",
        },
      },
    },
  })
  async createEvidence(
    @Body() evidenceData: ComplianceEvidenceDto,
    @UploadedFile(
      new ParseFilePipe({
        validators: [
          new MaxFileSizeValidator({ maxSize: 20 * 1024 * 1024 }), // 20MB
          new FileExtensionValidator({ allowedExtensions: ['pdf', 'csv', 'xls', 'xlsx'] }),
        ],
      }),
    )
    file: Express.Multer.File,
    @Request() request,
  ) {
    console.log("Received file:", file);
    console.log("MIME:", file.mimetype, "Size:", file.size);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        evidenceData.projectId,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_EVIDENCE_SUBMIT_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    const project = await this.projectService.findOne(+evidenceData.projectId);
    const fileName = project.slug + "/compliance/evidence/" + file.originalname;

    // TODO: Make the bucket name an env variable
    await this.storageProvider.uploadFile("turo", fileName, file.buffer);

    return this.evidenceService.createComplianceEvidence(
      evidenceData.name,
      evidenceData.description,
      +evidenceData.projectId,
      fileName,
      "turo",
      request.user.id,
    );
  }

  @Delete("/evidence/:evidenceId")
  async deleteEvidence(
    @Param("evidenceId", new ParseIntPipe()) evidenceId: number,
    @Request() request,
  ) {
    const evidence = await this.evidenceService.findOne(evidenceId);

    if (!evidence) {
      throw new HttpException("Evidence not found", HttpStatus.NOT_FOUND);
    }

    if (evidence.uploadedBy != request.user.id) {
      throw new UnauthorizedException("You are not allowed to delete this evidence");
    }

    try {
      await this.storageProvider.removeFile(
        evidence.bucketName,
        evidence.fileName,
      );
    } catch (error) {
      console.error(error);
      throw new HttpException(
        "Faced an error while deleting the file",
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
    await this.evidenceService.deleteComplianceEvidence(evidenceId);
  }

  @Get("/evidence/:evidenceId/download")
  async getEvidenceDownloadURL(
    @Res() res: Response,
    @Param("evidenceId", new ParseIntPipe()) evidenceId: number,
    @Request() request,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RISK_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    const evidence = await this.evidenceService.findOne(evidenceId);
    try {
      const fileStream = await this.storageProvider.getFile(
        evidence.bucketName,
        evidence.fileName,
      );

      // Set headers for file download
      res.setHeader(
        "Content-Disposition",
        `attachment; filename=${evidence.name}`,
      );
      res.setHeader("Content-Type", "application/octet-stream");

      // Pipe the file stream to the response
      fileStream.pipe(res);
    } catch (error) {
      throw new HttpException("File not found", HttpStatus.NOT_FOUND);
    }
  }

  /**
   * Function to create a compliance control
   * @param ruleData
   * @param request
   * @returns Promise<ComplianceRule>
   */
  @Post("/rules")
  async createComplianceRule(
    @Body() ruleData: ComplianceRuleDto,
    @Request() request,
  ): Promise<ComplianceRule> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_CREATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.ruleService.createComplianceRule(ruleData, request.user.id);
  }

  /**
   * Function to update a compliance control
   * @param ruleId
   * @param ruleData
   * @returns Promise<ComplianceRule>
   */
  @Post("/rules/:ruleId")
  async updateComplianceRule(
    @Param("ruleId", new ParseIntPipe()) ruleId: number,
    @Body() ruleData: UpdateComplianceRuleDto,
    @Request() request,
  ): Promise<ComplianceRule> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_UPDATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.ruleService.updateComplianceRule(
      ruleId,
      ruleData,
      request.user.id,
    );
  }

  /**
   * Function to delete a compliance control
   * @param ruleId
   * @returns Promise<ComplianceRule>
   */
  @Delete("/rules/:ruleId")
  async deleteComplianceRule(
    @Param("ruleId", new ParseIntPipe()) ruleId: number,
    @Request() request,
  ): Promise<ComplianceRule> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_DELETE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    const deletedRule = await this.ruleService.deleteRule(ruleId);
    await this.riskService.deleteRuleDependentRisk([ruleId]);
    return deletedRule;
  }

  /**
   * Function to get compliance controls
   * @returns Promise<ComplianceRule[]>
   */
  @Get("/rules")
  async getComplianceRules(@Request() request): Promise<ComplianceRule[]> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.ruleService.findAll();
  }

  /**
   * Function to get conpliance rule details
   * @param ruleId
   * @returns Promise<ComplianceRule>
   */
  @Get("/rules/:ruleId")
  async getComplianceRule(
    @Param("ruleId", new ParseIntPipe()) ruleId: number,
    @Request() request,
  ): Promise<ComplianceRule> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.ruleService.findOne(ruleId);
  }

  /**
   * Function to get projects dependent on a compliance control
   * @param ruleId
   * @returns Promise<number[]> List of project ids
   */
  @Get("rules/:ruleId/getDependentProjects")
  async getRuleDependentProjects(
    @Param("ruleId", new ParseIntPipe()) ruleId: number,
    @Request() request,
  ): Promise<number[]> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_RULE_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.riskService.getDependentProjects([ruleId]);
  }

  /**
   * Function to get projects dependent on a compliance policy
   * @param policyId
   * @returns Promise<number[]> List of project ids
   */
  @Get("policies/:policyId/getDependentProjects")
  async getPolicyDependentProjects(
    @Param("policyId", new ParseIntPipe()) policyId: number,
    @Request() request,
  ): Promise<number[]> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    // find the latest submission for the policy
    const activeSubmissions = await this.complianceService.getActiveSubmissionsForPolicy(
      policyId,
    );

    return activeSubmissions.map((submission) => submission.project["id"]);
  }

  /**
   * Function to create a compliance policy
   * @param policyData
   * @param request
   * @returns Promise<CompliancePolicy>
   */
  @Post("/policies")
  async createCompliancePolicy(
    @Body() policyData: CompliancePolicyDto,
    @Request() request,
  ): Promise<CompliancePolicy> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_CREATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.compliancePolicyService.createCompliancePolicy(
      policyData,
      request.user.id,
    );
  }

  /**
   * Function to update a compliance policy
   * @param policyId
   * @param policyData
   * @returns Promise<CompliancePolicy>
   */
  @Post("/policies/:policyId")
  async updateCompliancePolicy(
    @Param("policyId", new ParseIntPipe()) policyId: number,
    @Body() policyData: UpdateCompliancePolicyDto,
    @Request() request,
  ): Promise<CompliancePolicy> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_UPDATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    const updatedPolicy =
      await this.compliancePolicyService.updateCompliancePolicy(
        policyId,
        policyData,
        request.user.id,
      );

    const dependentProjects = await this.getPolicyDependentProjects(
      policyId,
      request,
    );
    dependentProjects.forEach(async (projectId) => {
      const existingSubmission =
        await this.complianceService.getLatestProjectDependentSubmissions(
          projectId,
        );
      await this.complianceService.triggerSubmitComplianceWorkflow(
        existingSubmission,
      );
    });
    return updatedPolicy;
  }

  /**
   * Function to delete a compliance policy
   * @param policyId
   * @returns Promise<CompliancePolicy>
   */
  @Delete("/policies/:policyId")
  async deleteCompliancePolicy(
    @Param("policyId", new ParseIntPipe()) policyId: number,
    @Request() request,
  ): Promise<CompliancePolicy> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_DELETE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    const deletedPoilcy =
      await this.compliancePolicyService.deleteCompliancePolicy(policyId);
    await this.riskService.deletePolicyDependentRisk(deletedPoilcy.id);
    return deletedPoilcy;
  }

  /**
   * Function to list compliance policies
   * it also filters policies based on jurisdictions if provided
   * @param jurisdictions
   * @returns Promise<CompliancePolicy[]>
   */
  @Get("/policies")
  async getCompliancePolicies(
    @Request() request,
    @Query("jurisdictions") jurisdictions?: string,
  ): Promise<CompliancePolicy[]> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.compliancePolicyService.getPolicies(
      CompliancePolicySource.INTERNAL,
      jurisdictions ? (jurisdictions.split(",") as Jurisdiction[]) : [],
    );
  }

  /**
   * Function to get compliance policy details
   * @param policyId
   * @returns Promise<CompliancePolicy>
   */
  @Get("/policies/:policyId")
  async getCompliancePolicy(
    @Param("policyId", new ParseIntPipe()) policyId: number,
    @Request() request,
  ): Promise<CompliancePolicy> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        0,
        COMPLIANCE_RESOURCE_NAME,
        COMPLIANCE_POLICY_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.compliancePolicyService.findOne(policyId);
  }
}