import { extname } from "node:path";
import {
  Controller,
  Post,
  Body,
  Param,
  UseGuards,
  Get,
  UseInterceptors,
  UploadedFile,
} from "@nestjs/common";
import { FileInterceptor } from "@nestjs/platform-express";
import { diskStorage } from "multer";
import {
  ApiBearerAuth,
  ApiBody,
  ApiParam,
  ApiTags,
  ApiOperation,
  ApiResponse,
  ApiConsumes,
} from "@nestjs/swagger";
import { LocalActorAuthGuard } from "src/auth/guards/actor-local.guard";
import { RolesGuard } from "src/auth/guards/role.guard";
import { CurrentUser } from "src/decorators/user.decorator";
import { Roles } from "src/decorators/roles.decorator";
import { MediaPolicyService } from "src/media-policy/media-policy.service";
import { DEFAULT_MEDIA_MAX_BYTES } from "src/client/client.service";
import { RoleEnum } from "src/Types&Enums/role.enum";
import { RequestManagementService } from "./request-management.service";
import { CreateExpertInitiatedFileDto } from "./dto/expert-initiated.dto";
import { ExpertCompleteThirdPartyFormV2Dto } from "./dto/expert-complete-third-party-form.v2.dto";
import { ExpertCompleteCarBodyFormV2Dto } from "./dto/expert-complete-car-body-form.v2.dto";
import { ExpertAccidentFieldsDto } from "./dto/expert-accident-fields.dto";
import { ExpertCompleteClaimDataDto } from "./dto/expert-complete-claim-data.dto";
import { ExpertUploadPartySignatureDto } from "./dto/expert-upload-party-signature.dto";
import { VerifyPartyOtpsDto } from "./dto/verify-party-otps.dto";
import { SendPartyOtpsDto } from "./dto/send-party-otps.dto";
import { SendExpertInitiatedLinkV2Dto } from "./dto/send-expert-initiated-link.v2.dto";
import { ExpertCompleteLocationV2Dto } from "./dto/expert-complete-location.v2.dto";
import { ClaimRequestManagementService } from "src/claim-request-management/claim-request-management.service";
import { PartyRole } from "./entities/schema/partyRole.enum";

/**
 * V2 expert-initiated blame API: uses BlameRequest (workflow) model.
 * Field experts create files via LINK (send link to user) or IN_PERSON (expert fills on-site).
 * Only the initiating field expert can see/review these files.
 */
// @ApiTags("expert-initiated-blame (v2)")
@Controller("v2/expert-initiated-blame")
@ApiBearerAuth()
@UseGuards(LocalActorAuthGuard, RolesGuard)
@Roles(RoleEnum.FIELD_EXPERT)
export class ExpertInitiatedV2Controller {
  constructor(
    private readonly requestManagementService: RequestManagementService,
    private readonly claimRequestManagementService: ClaimRequestManagementService,
    private readonly mediaPolicyService: MediaPolicyService,
  ) {}

  @Get("my-files")
  // @ApiOperation({
  //   summary: "[V2] List my expert-initiated blame files",
  //   description:
  //     "Returns all BlameRequest (workflow) files created by the current field expert.",
  // })
  // @ApiResponse({ status: 200, description: "List of expert-initiated files" })
  async getMyFilesV2(@CurrentUser() expert: any) {
    return this.requestManagementService.getMyExpertInitiatedFilesV2(expert);
  }

  @Get("blame/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Get one expert-initiated blame request",
  //   description: "Returns a single blame request. Only the initiating field expert can access.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiResponse({ status: 200, description: "Blame request" })
  async getBlameRequestV2(
    @Param("requestId") requestId: string,
    @CurrentUser() expert: any,
  ) {
    return this.requestManagementService.getBlameRequestV2(requestId, expert);
  }

  @Post("create")
  // @ApiOperation({
  //   summary: "[V2] Create expert-initiated blame file",
  //   description:
  //     "Creates a BlameRequest with workflow. LINK: parties identified by phone, expert sends link. IN_PERSON: expert fills form later.",
  // })
  // @ApiBody({
  //   type: CreateExpertInitiatedFileDto,
  //   examples: {
     // thirdPartyInPerson: {
     //   summary: "Third-party, IN_PERSON (both parties)",
     //   description:
     //     "Expert fills form on-site for both parties.",
     //   value: {
          // type: "THIRD_PARTY",
          // creationMethod: "LINK",
          // firstPartyPhoneNumber: "09123456789",
        // },
      // },
      // carBodyInPerson: {
      //   summary: "Car-body, IN_PERSON",
      //   description: "Expert fills form on-site for single party (car body).",
      //   value: {
      //     type: "CAR_BODY",
      //     creationMethod: "IN_PERSON",
      //     firstPartyPhoneNumber: "09123456789",
      //   },
      // },
     //  carBodyLink: {
     //   summary: "Car-body, LINK",
     //   description:
     //     "Expert sends link to party by phone. Only first party phone needed.",
     //   value: {
     //     type: "CAR_BODY",
     //     creationMethod: "LINK",
     //     firstPartyPhoneNumber: "09123456789",
      //     },
      // },
    // },
  // })
  async createV2(
    @CurrentUser() expert: any,
    @Body() dto: CreateExpertInitiatedFileDto,
  ) {
    return this.requestManagementService.createExpertInitiatedBlameV2(
      expert,
      dto,
    );
  }

  @Post("send-link/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Send blame link to first party (LINK)",
  //   description:
  //     "For expert-initiated LINK files only. Provide the first party phone number; the service stores it, registers the user if needed, and sends the invite link via SMS.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({ type: SendExpertInitiatedLinkV2Dto })
  async sendLinkV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() dto: SendExpertInitiatedLinkV2Dto,
  ) {
    return this.requestManagementService.sendLinkV2(expert, requestId, dto);
  }

  @Post("send-party-otps/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Send OTP to party/parties (IN_PERSON)",
  //   description:
  //     "Sends OTP via SMS to first party (and second party for THIRD_PARTY) using the same flow as /user/send-otp. Parties receive the code; collect it from them and call verify-party-otps. Call this before filling the blame form.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({ type: SendPartyOtpsDto })
  // @ApiResponse({ status: 200, description: "OTP(s) sent; collect codes and call verify-party-otps" })
  async sendPartyOtpsV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() dto: SendPartyOtpsDto,
  ) {
    return this.requestManagementService.sendPartyOtpsV2(expert, requestId, dto);
  }

  @Post("verify-party-otps/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Verify party OTPs (IN_PERSON)",
  //   description:
  //     "After send-party-otps, parties receive SMS. They tell you the code; submit it here. Required before complete-blame-data.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({ type: VerifyPartyOtpsDto })
  // @ApiResponse({ status: 200, description: "OTPs verified; expert can proceed to complete-blame-data" })
  async verifyPartyOtpsV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() dto: VerifyPartyOtpsDto,
  ) {
    return this.requestManagementService.verifyPartyOtpsV2(expert, requestId, dto);
  }

  @Post("complete-blame-data/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Submit all blame data (IN_PERSON)",
  //   description:
  //     "For IN_PERSON files only. Send THIRD_PARTY or CAR_BODY form EXCEPT location. Use one shared expertDescription (not per-party descriptions). After this, call add-locations once to submit scene lat/lon and move workflow to WAITING_FOR_SIGNATURES.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({
  //   description: "Choose THIRD_PARTY or CAR_BODY example according to the file type. IN_PERSON v2 uses one shared expertDescription for the scene.",
  //   examples: {
  //     THIRD_PARTY: {
  //       summary: "THIRD_PARTY",
  //       description: "Use when the blame file type is THIRD_PARTY",
  //       value: {
  //         firstPartyPhoneNumber: "09123456789",
  //         firstPartyInitialForm: {
  //           expertOpinion: false,
  //           imDamaged: false,
  //           imGuilty: true,
  //         },
  //         firstPartyPlate: {
  //           nationalCodeOfInsurer: "",
  //           nationalCodeOfDriver: "",
  //           insurerLicense: "",
  //           driverLicense: "",
  //           plate: { leftDigits: 12, centerAlphabet: "الف", centerDigits: 345, ir: 22 },
  //           driverIsInsurer: true,
  //           isNewCar: false,
  //           userNoCertificate: false,
  //           insurerBirthday: 13770624,
  //           driverBirthday: "1370-01-01",
  //         },
  //         expertDescription: { desc: "توضیح حادثه کارشناس (مشترک برای صحنه)" },
  //         secondParty: {
  //           phoneNumber: "09187654321",
  //           initialForm: {
  //             expertOpinion: false,
  //             imDamaged: true,
  //             imGuilty: false,
  //           },
  //           plate: {
  //             nationalCodeOfInsurer: "",
  //             nationalCodeOfDriver: "",
  //             insurerLicense: "",
  //             driverLicense: "",
  //             plate: { leftDigits: 91, centerAlphabet: "ن", centerDigits: 174, ir: 79 },
  //             driverIsInsurer: true,
  //             isNewCar: false,
  //             userNoCertificate: false,
  //             insurerBirthday: 13700720,
  //             driverBirthday: "1370-01-01",
  //           },
  //         },
  //         guiltyPartyPhoneNumber: "09123456789",
  //       },
  //     },
  //     CAR_BODY: {
  //       summary: "CAR_BODY",
  //       description: "Use when the blame file type is CAR_BODY",
  //       value: {
  //         firstPartyPhoneNumber: "09123456789",
  //         firstPartyInitialForm: {
  //           expertOpinion: false,
  //           imDamaged: false,
  //           imGuilty: true,
  //         },
  //         carBodyForm: { car: true, object: false },
  //         firstPartyPlate: {
  //           plateId: "",
  //           nationalCodeOfInsurer: "",
  //           nationalCodeOfDriver: "",
  //           insurerLicense: "",
  //           driverLicense: "",
  //           plate: { leftDigits: 12, centerAlphabet: "الف", centerDigits: 345, ir: 22 },
  //           driverIsInsurer: true,
  //           isNewCar: false,
  //           userNoCertificate: false,
  //           insurerBirthday: 1370,
  //           driverBirthday: "1370-01-01",
  //         },
  //         expertDescription: {
  //           desc: "توضیح حادثه",
  //           accidentDate: "2025-01-15",
  //           accidentTime: "14:30",
  //           weatherCondition: "صاف",
  //           roadCondition: "خشک",
  //           lightCondition: "روز",
  //         },
  //       },
  //     },
  //   },
  //   schema: { type: "object" },
  // })
  // @ApiResponse({ status: 200, description: "Blame form completed; next: add-locations" })
  async completeBlameDataV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() formData: ExpertCompleteThirdPartyFormV2Dto | ExpertCompleteCarBodyFormV2Dto,
  ) {
    return this.requestManagementService.expertCompleteBlameDataV2(
      expert,
      requestId,
      formData,
    );
  }

  @Post("add-locations/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Submit one scene location for expert-initiated IN_PERSON blame",
  //   description:
  //     "Submit one scene location after complete-blame-data. This transitions workflow to WAITING_FOR_SIGNATURES.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({
  //   type: ExpertCompleteLocationV2Dto,
  //   examples: {
  //     scene: {
  //       summary: "One scene location (all IN_PERSON types)",
  //       value: {
  //         location: { lat: 35.6892, lon: 51.389 },
  //       },
  //     },
    // },
  // })
  // @ApiResponse({ status: 200, description: "Locations saved; next: upload party signature(s)" })
  async addLocationsV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() dto: ExpertCompleteLocationV2Dto,
  ) {
    return this.requestManagementService.expertAddLocationsForBlameV2(
      expert,
      requestId,
      dto as any,
    );
  }

  @Post("upload-video/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Expert uploads video for expert-initiated BlameRequest",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiConsumes("multipart/form-data")
  // @ApiBody({
  //   schema: {
  //     type: "object",
  //     properties: { file: { type: "string", format: "binary" } },
  //   },
  // })
  @UseInterceptors(
    FileInterceptor("file", {
      limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
      storage: diskStorage({
        destination: "./files/video",
        filename: (req, file, callback) => {
          const unique = Date.now();
          const ex = extname(file.originalname);
          callback(null, `expert-${file.originalname}-${unique}${ex}`);
        },
      }),
    }),
  )
  // @ApiResponse({ status: 200, description: "Video uploaded" })
  async uploadVideoV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @UploadedFile() file?: Express.Multer.File,
  ) {
    await this.mediaPolicyService.assertForBlame(file, requestId, "video");
    return this.requestManagementService.expertUploadVideoForBlameV2(
      expert,
      requestId,
      file,
    );
  }

  @Post("upload-voice/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Expert uploads voice for expert-initiated BlameRequest",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiConsumes("multipart/form-data")
  // @ApiBody({
  //   schema: {
  //     type: "object",
  //     properties: { voice: { type: "string", format: "binary" } },
  //   },
  // })
  @UseInterceptors(
    FileInterceptor("voice", {
      limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
      storage: diskStorage({
        destination: "./files/voice",
        filename: (req, file, callback) => {
          const unique = Date.now();
          const ex = extname(file.originalname);
          const flname = file.originalname.split(".")[0];
          callback(null, `expert-${flname}-${unique}${ex}`);
        },
      }),
    }),
  )
  // @ApiResponse({ status: 200, description: "Voice uploaded" })
  async uploadVoiceV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @UploadedFile() voice?: Express.Multer.File,
  ) {
    await this.mediaPolicyService.assertForBlame(voice, requestId, "voice");
    return this.requestManagementService.expertUploadVoiceForBlameV2(
      expert,
      requestId,
      voice,
    );
  }

  @Post("add-accident-fields/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Expert adds accident fields to expert-initiated BlameRequest",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiBody({ type: ExpertAccidentFieldsDto })
  // @ApiResponse({ status: 200, description: "Accident fields added" })
  async addAccidentFieldsV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() fields: ExpertAccidentFieldsDto,
  ) {
    return this.requestManagementService.expertAddAccidentFieldsForBlameV2(
      expert,
      requestId,
      fields,
    );
  }

  @Post("upload-party-signature/:requestId")
  // @ApiOperation({
  //   summary: "[V2] Expert uploads party signature (IN_PERSON)",
  //   description:
  //     "For IN_PERSON only. Upload a party's signature collected on-site. CAR_BODY: use partyRole FIRST once. THIRD_PARTY: upload FIRST then SECOND. When all required parties have signed, blame case completes.",
  // })
  // @ApiParam({ name: "requestId", description: "Blame request ID" })
  // @ApiConsumes("multipart/form-data")
  // @ApiBody({
  //   schema: {
  //     type: "object",
  //     required: ["partyRole", "sign"],
  //     properties: {
  //       partyRole: { type: "string", enum: ["FIRST", "SECOND"] },
  //       isAccept: { type: "boolean", default: true },
  //       sign: { type: "string", format: "binary" },
  //     },
  //   },
  // })
  @UseInterceptors(
    FileInterceptor("sign", {
      limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
      storage: diskStorage({
        destination: "./files/signs",
        filename: (req, file, callback) => {
          const unique = Date.now();
          const ex = extname(file.originalname);
          callback(null, `expert-party-${unique}${ex}`);
        },
      }),
    }),
  )
  // @ApiResponse({ status: 200, description: "Signature recorded" })
  async uploadPartySignatureV2(
    @CurrentUser() expert: any,
    @Param("requestId") requestId: string,
    @Body() body: { partyRole?: string; isAccept?: string | boolean },
    @UploadedFile() sign?: Express.Multer.File,
  ) {
    await this.mediaPolicyService.assertForBlame(sign, requestId, "image");

    const partyRole = (body.partyRole === "FIRST" || body.partyRole === "SECOND")
      ? body.partyRole
      : ("FIRST" as const);
    const isAccept = body.isAccept === false || body.isAccept === "false" ? false : true;
    return this.requestManagementService.expertUploadPartySignatureV2(
      expert,
      requestId,
      partyRole as PartyRole,
      isAccept,
      sign!,
    );
  }

  @Post("create-claim-from-blame/:blameRequestId")
  // @ApiOperation({
  //   summary: "[V2] Create claim from expert-initiated IN_PERSON blame",
  //   description:
  //     "Field expert creates a claim on behalf of the damaged party. Blame must be COMPLETED (signatures collected). Then use claim v2 endpoints to fill parts, documents, and captures.",
  // })
  // @ApiParam({ name: "blameRequestId", description: "Completed blame request ID" })
  // @ApiResponse({ status: 201, description: "Claim created" })
  async createClaimFromBlame(
    @CurrentUser() expert: any,
    @Param("blameRequestId") blameRequestId: string,
  ) {
    return this.claimRequestManagementService.createClaimFromBlameForExpertV2(
      blameRequestId,
      expert,
    );
  }

  @Post("complete-claim-data/:claimRequestId")
  // @ApiOperation({
  //   summary: "Submit claim-needed data (expert-initiated IN_PERSON)",
  // })
  // @ApiParam({ name: "claimRequestId", description: "Claim file ID" })
  // @ApiBody({ type: ExpertCompleteClaimDataDto })
  // @ApiResponse({ status: 200, description: "Claim data updated" })
  async completeClaimData(
    @CurrentUser() expert: any,
    @Param("claimRequestId") claimRequestId: string,
    @Body() dto: ExpertCompleteClaimDataDto,
  ) {
    return this.claimRequestManagementService.expertCompleteClaimData(
      claimRequestId,
      expert,
      dto,
    );
  }
}