import { HttpService } from "@nestjs/axios";
import {
  BadGatewayException,
  BadRequestException,
  GatewayTimeoutException,
  Injectable,
  Logger,
  NotFoundException,
  ServiceUnavailableException,
  UnauthorizedException,
} from "@nestjs/common";
import { SandHubDbService } from "src/sand-hub/entity/db-service/sand-hub.db.service";
import { SandHubModel } from "src/sand-hub/entity/schema/sand-hub.schema";
import { ExternalInquirySettingsService } from "src/client/external-inquiry-settings.service";
import type { ExternalInquiryType } from "src/common/types/external-inquiry.types";
import type { MockInquiryCompanyContext } from "src/common/types/external-inquiry.types";
import { SandHubDetailDto, SandHubInquiryOptions } from "./dto/sand-hub.dto";
import { jalaliToGregorianDate } from "src/helpers/date-jalali";
import { firstValueFrom } from "rxjs";

@Injectable()
export class SandHubService {
  private static readonly ESG_INQUIRY_UNAVAILABLE_MESSAGE =
    "استعلام در دسترس نیست";

  private readonly logger = new Logger(SandHubService.name);
  private loginToken: string | null = null;
  private tokenExpiry: Date | null = null;

  // Tejarat inquiry auth (82.99.202.245:3027)
  private tejaratAccessToken: string | null = null;
  private tejaratTokenExpiry: Date | null = null;

  // ESG inquiry auth (used for selected tenants, e.g. CLIENT_ID=8)
  private esgAccessToken: string | null = null;
  private esgTokenExpiry: Date | null = null;

  constructor(
    private readonly httpService: HttpService,
    private readonly sandHubDbService: SandHubDbService,
    private readonly externalInquirySettings: ExternalInquirySettingsService,
  ) {}

  private clientRefFrom(options?: SandHubInquiryOptions): string | undefined {
    return options?.clientId;
  }

  private async isInquiryLive(
    type: ExternalInquiryType,
    options?: SandHubInquiryOptions,
  ): Promise<boolean> {
    return this.externalInquirySettings.isInquiryLive(
      type,
      this.clientRefFrom(options),
    );
  }

  private async mockCompanyContext(
    options?: SandHubInquiryOptions,
  ): Promise<MockInquiryCompanyContext> {
    return this.externalInquirySettings.getMockCompanyContext(
      this.clientRefFrom(options),
    );
  }

  private shouldUseEsgInquiryProvider(): boolean {
    return String(process.env.CLIENT_ID ?? "") === "8";
  }

  /** Fixed plate/insurance inquiry payload used everywhere we mock block-inquiry style APIs. */
  private buildMockPlateInquiryRaw(
    ctx: MockInquiryCompanyContext,
  ): Record<string, unknown> {
    return {
      PrntPlcyCmpDocNo: "1404/1143-70591/200/123",
      MapTypNam: "فائو ( FAW )",
      MtrNum: "TZ196XYAP223A210074",
      ShsNum: "LFP8C7PC3R1K12157",
      DisFnYrNum: null,
      DisLfYrNum: null,
      DisPrsnYrNum: null,
      DisPrsnYrPrcnt: null,
      DisFnYrPrcnt: "5",
      DisLfYrPrcnt: "5",
      vin: "LFP8C7PC3R1K12157",
      MapVehicleSystemName: "ثبت نشده",
      LfCvrCptl: 0,
      FnCvrCptl: 0,
      PrsnCvrCptl: 0,
      VehicleSystemCode: 1,
      EdrsJson: "",
      PersonCvrCptl: 12000000000,
      LifeCvrCptl: 16000000000,
      FinancialCvrCptl: 4000000000,
      CarGroupCode: 3,
      CylCnt: 4,
      LastCompanyDocumentNumber: "31/3100/03/18350",
      UsageCode: "8",
      MapUsageCode: 1,
      MapUsageName: "شخصي",
      Plk1: 16,
      Plk2: 12,
      Plk3: 498,
      PlkSrl: 60,
      PrintEndorsCompanyDocumentNumber: "",
      EndorseDate: null,
      InsuranceFullName: null,
      SystemField: "سايپا",
      TypeField: "111SE",
      UsageField: "سواري",
      MainColorField: "سفيد",
      SecondColorField: "سفيد شيري",
      ModelField: "2024",
      CapacityField: "جمعا 4 نفر",
      CylinderNumberField: "4",
      EngineNumberField: "5215907",
      ChassisNumberField: "LFP8C7PC3R1K12157",
      VinNumberField: "LFP8C7PC3R1K12157",
      InstallDateField: "1403/03/01",
      AxelNumberField: "2",
      WheelNumberField: "4",
      CompanyName: ctx.companyName,
      CompanyCode: ctx.companyId,
      IssueDate: "1403/04/06",
      SatrtDate: "1403/04/06",
      EndDate: "1404/04/06",
      Thrname: "",
      EndorseText: null,
      PolicyHealthLossCount: 0,
      PolicyFinancialLossCount: 0,
      PolicyPersonLossCount: 0,
      Tonage: 0,
      ThirdPolicyCode: 10502330579,
      DiscountPersonPercent: null,
      DiscountThirdPercent: null,
      SystemCodeCii: 0,
      SystemNameCii: "ثبت نشده",
      TypeCodeCii: 12189,
      TypeNameCii: "فائو ( FAW )",
      UsageNameCii: "سواري",
      UsageCodeCii: 1,
      ModelCii: 2024,
      damageTypes: [],
      StatusTypeCode: 1,
    };
  }

  /** Build {@link SandHubDetailDto} from Tejarat badane / block-inquiry request bodies. */
  private tejaratPayloadToSandHubDetail(payload: {
    nationalCode?: string | number;
    part1?: string | number;
    part2?: string | number;
    part3?: string | number;
    part4?: string | number;
    leftTwoDigits?: string | number;
    serialLetter?: string | number;
    threeDigits?: string | number;
    rightTwoDigits?: string | number;
  }): SandHubDetailDto {
    const nationalCode = String(payload.nationalCode ?? "");
    return {
      nationalCodeOfInsurer: nationalCode,
      plate: {
        leftDigits: Number(payload.part1 ?? payload.leftTwoDigits ?? 16),
        centerAlphabet: String(
          payload.part2 ?? payload.serialLetter ?? "12",
        ),
        centerDigits: Number(payload.part3 ?? payload.threeDigits ?? 498),
        ir: Number(payload.part4 ?? payload.rightTwoDigits ?? 60),
        nationalCode,
      },
    };
  }

  private buildMockCarBodyInquiryRaw(
    userDetail: SandHubDetailDto,
    ctx: MockInquiryCompanyContext,
  ): Record<string, unknown> {
    const companyId = Number(ctx.companyId);
    const plate = userDetail?.plate;
    const platePartOne = Number(plate?.leftDigits ?? 16);
    const platePartThree = Number(plate?.centerDigits ?? 498);
    const plateSerialNumber = Number(plate?.ir ?? 60);
    const plateLetterid = Number(plate?.centerAlphabet ?? 12);
    const nationalCode = String(userDetail?.nationalCodeOfInsurer ?? "");

    return {
      data: {
        id: 70016075946,
        printNumber: "1405/1143-70591/220/1/0",
        companyId: Number.isNaN(companyId) ? 15 : companyId,
        companyName: ctx.companyName,
        beginDate: "1405/01/17",
        endDate: "1406/01/17",
        issueDate: "1405/01/16",
        hasEndorsement: null,
        motorNumber: "TZ196XYAP223A210074",
        chassisNumber: "LFP8C7PC3R1K12157",
        vin: "LFP8C7PC3R1K12157",
        plateTypeId: 9,
        plateTypeTitle: "پلاک قدیمی",
        platePartOne,
        plateSerialNumber,
        plateLetterid,
        plateLetterTitle: "م  ",
        vehicleSystemTitle: "فائو ( FAW )",
        vehicleGroupId: 2,
        vehicleGroupTitle: "سواری چهار سیلندر",
        insurerNationalCode: nationalCode,
        insurerName: "هانيه کارخانهء",
        ownerNationalCode: nationalCode,
        previousId: 70006331822,
        noLossYearsCount: 4,
        platePartThree,
        lossDocuments: [],
      },
      isSuccess: true,
      statusCode: 200,
      message: "عملیات با موفقیت انجام شد",
    };
  }

  private buildMockInquiryRaw(
    inquiryType: ExternalInquiryType,
    ctx: MockInquiryCompanyContext,
    payload?: unknown,
    userDetail?: SandHubDetailDto,
  ): Record<string, unknown> {
    if (inquiryType === "carBodyPlate") {
      const detail =
        userDetail ??
        this.tejaratPayloadToSandHubDetail(
          (payload ?? {}) as Record<string, unknown>,
        );
      return this.buildMockCarBodyInquiryRaw(detail, ctx);
    }
    return this.buildMockPlateInquiryRaw(ctx);
  }

  /**
   * Bodies returned from `makeSandHubRequest` in mock mode (same shape callers expect from real API).
   */
  private buildMockSandHubResponseForUrl(
    url: string,
    payload?: unknown,
    plateMock?: Record<string, unknown>,
  ): any {
    const u = (url || "").toLowerCase();
    if (u.includes("personal-inquiry")) {
      const p = payload as { nationalCode?: string } | undefined;
      const nin = typeof p?.nationalCode === "string" ? p.nationalCode : "-";
      return {
        message: "success",
        data: {
          firstName: "نام",
          lastName: "خانوادگی",
          fatherName: "-",
          birthCertificateNumber: "-",
          nin,
        },
      };
    }
    if (u.includes("driver-license-check")) {
      return {
        data: {
          IsSucceed: true,
          Message: "mock",
        },
      };
    }
    if (u.includes("ownership")) {
      return {
        data: {
          IsSuccess: true,
        },
      };
    }
    if (u.includes("sheba")) {
      return {
        ReturnValue: true,
        HasError: false,
        Message: "mock-sheba-ok",
      };
    }
    if (u.includes("badane")) {
      return (
        plateMock ??
        this.buildMockCarBodyInquiryRaw(
          this.tejaratPayloadToSandHubDetail(
            (payload ?? {}) as Record<string, unknown>,
          ),
          {
            companyId: process.env.CLIENT_ID ?? "15",
            companyName: process.env.CLIENT_NAME ?? "بیمه سامان",
          },
        )
      );
    }
    if (u.includes("block-inquiry") || u.includes("tejarat")) {
      return this.mapNewApiResponseToOldFormat(
        plateMock ??
          this.buildMockPlateInquiryRaw({
            companyId: process.env.CLIENT_ID ?? "15",
            companyName: process.env.CLIENT_NAME ?? "بیمه سامان",
          }),
      );
    }
    this.logger.warn(
      `[MOCK] Unrecognized SandHub URL; returning generic OK: ${url}`,
    );
    return { data: {}, message: "mock-ok" };
  }

  private async getAccessToken(): Promise<string> {
    if (this.loginToken && this.tokenExpiry && this.tokenExpiry > new Date()) {
      return this.loginToken;
    }

    this.logger.log(
      "SandHub token is missing or expired. Fetching a new one...",
    );

    try {
      const response = await firstValueFrom(
        this.httpService.post(process.env.SANHUB_URL_LOGIN, {
          email: process.env.SANHUB_USERNAME,
          password: process.env.SANHUB_PASSWORD,
        }),
      );

      const token = response.data.accessToken;

      if (!token)
        throw new Error("No access token returned from SandHub login");

      this.loginToken = token;
      this.tokenExpiry = new Date(Date.now() + 55 * 60 * 1000); // 55-minute expiry

      this.logger.log("Successfully obtained a new SandHub token.");

      return this.loginToken;
    } catch (er) {
      this.logger.error("Failed to login to SandHub:", er.message);
      this.loginToken = null;
      this.tokenExpiry = null;
      throw new UnauthorizedException("SandHub authentication failed");
    }
  }

  private async getTejaratAccessToken(): Promise<string> {
    if (
      this.tejaratAccessToken &&
      this.tejaratTokenExpiry &&
      this.tejaratTokenExpiry > new Date()
    ) {
      return this.tejaratAccessToken;
    }

    const baseUrl =
      process.env.TEJARAT_INQUIRY_BASE_URL ?? "http://82.99.202.245:3027";
    const email = process.env.TEJARAT_INQUIRY_EMAIL;
    const password = process.env.TEJARAT_INQUIRY_PASSWORD;

    if (!email || !password) {
      throw new UnauthorizedException(
        "Tejarat inquiry credentials are not configured (TEJARAT_INQUIRY_EMAIL/TEJARAT_INQUIRY_PASSWORD)",
      );
    }

    this.logger.log(
      "Tejarat inquiry token is missing or expired. Fetching a new one...",
    );

    try {
      const response = await firstValueFrom(
        this.httpService.post(
          `${baseUrl}/user/login`,
          { email, password },
          {
            headers: {
              Accept: "*/*",
              "Content-Type": "application/json",
            },
            timeout: 30000,
          },
        ),
      );

      const token = response.data?.accessToken;
      if (!token) {
        throw new Error("No access token returned from Tejarat login");
      }

      this.tejaratAccessToken = token;
      // No explicit expiry in response; keep a conservative cache window.
      this.tejaratTokenExpiry = new Date(Date.now() + 55 * 60 * 1000);

      return this.tejaratAccessToken;
    } catch (er) {
      this.logger.error(
        "Failed to login to Tejarat inquiry:",
        er?.message || er,
      );
      this.tejaratAccessToken = null;
      this.tejaratTokenExpiry = null;
      throw new UnauthorizedException("Tejarat inquiry authentication failed");
    }
  }

  private async getEsgAccessToken(): Promise<string> {
    if (this.esgAccessToken && this.esgTokenExpiry && this.esgTokenExpiry > new Date()) {
      return this.esgAccessToken;
    }

    const baseUrl = process.env.ESG_URL;
    const username = process.env.ESG_USERNAME;
    const password = process.env.ESG_PASSWORD;

    if (!baseUrl || !username || !password) {
      throw new UnauthorizedException(
        "ESG credentials are not configured (ESG_URL/ESG_USERNAME/ESG_PASSWORD)",
      );
    }

    this.logger.log("ESG token is missing or expired. Fetching a new one...");

    try {
      const response = await firstValueFrom(
        this.httpService.post(
          `${baseUrl}/auth/login`,
          { username, password },
          {
            headers: {
              Accept: "application/json",
              "Content-Type": "application/json",
            },
            timeout: 30000,
          },
        ),
      );

      const token = response.data?.accessToken;
      if (!token) {
        throw new Error("No access token returned from ESG login");
      }

      const expiresInSeconds = Number(response.data?.expiresIn ?? 900);
      const ttlMs = Number.isFinite(expiresInSeconds)
        ? Math.max(30, expiresInSeconds - 60) * 1000
        : 14 * 60 * 1000;

      this.esgAccessToken = token;
      this.esgTokenExpiry = new Date(Date.now() + ttlMs);
      return this.esgAccessToken;
    } catch (er: any) {
      this.logger.error("Failed to login to ESG inquiry:", er?.message || er);
      this.esgAccessToken = null;
      this.esgTokenExpiry = null;
      throw new UnauthorizedException("ESG inquiry authentication failed");
    }
  }

  private async makeEsgRequest(
    url: string,
    payload: any,
    inquiryType: ExternalInquiryType,
    options?: SandHubInquiryOptions,
    maxRetries = 2,
  ) {
    if (!(await this.isInquiryLive(inquiryType, options))) {
      this.logger.log(`[MOCK] ESG POST skipped (${inquiryType}): ${url}`);
      const ctx = await this.mockCompanyContext(options);
      if (inquiryType === "personalIdentity") {
        const nin =
          typeof payload?.nationalCode === "string"
            ? payload.nationalCode
            : "-";
        return this.getDefaultMockPersonInquiry(nin);
      }
      if (inquiryType === "sheba") {
        return {
          ReturnValue: true,
          HasError: false,
          Message: "mock-sheba-ok",
        };
      }
      return this.buildMockInquiryRaw(inquiryType, ctx, payload);
    }

    const INITIAL_DELAY = 500;
    const BACKOFF_FACTOR = 2;

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      const token = await this.getEsgAccessToken();
      try {
        const response = await firstValueFrom(
          this.httpService.post(url, payload, {
            headers: {
              Authorization: `Bearer ${token}`,
              "Content-Type": "application/json",
              Accept: "application/json",
            },
            timeout: 30000,
          }),
        );
        if (!response?.data) throw new Error("EMPTY_RESPONSE");
        return response.data;
      } catch (err: any) {
        const status = err?.response?.status;
        const data = err?.response?.data;
        this.logger.error(
          `ESG request failed (attempt ${attempt + 1}/${maxRetries}) to ${url} with status ${
            status ?? "NO_STATUS"
          }`,
          data ? JSON.stringify(data) : err?.message || err,
        );

        if (status === 401) {
          this.esgAccessToken = null;
          this.esgTokenExpiry = null;
        }

        const delay = INITIAL_DELAY * Math.pow(BACKOFF_FACTOR, attempt);
        await new Promise((resolve) => setTimeout(resolve, delay));
        if (attempt === maxRetries - 1) throw err;
      }
    }
  }

  private mapEsgPolicyByPlateToOldFormat(raw: any): any {
    if (!raw) return raw;

    if (raw?.success === false) {
      this.logger.warn(
        "ESG policyByPlate inquiry returned success=false",
        raw,
      );
      return {
        Error: {
          Message: SandHubService.ESG_INQUIRY_UNAVAILABLE_MESSAGE,
        },
      };
    }

    // Real ESG response wraps payload in { success: true, data: { ... } }.
    // Mock data and Tejarat-format fallback are flat objects with no .data wrapper —
    // in that case use raw itself so CompanyName / CompanyCode are preserved.
    const data =
      raw?.data != null && typeof raw?.data === "object" ? raw.data : raw;
    return this.mapNewApiResponseToOldFormat({
      ...data,
      companyId: data.CmpCod ?? data.companyId ?? data.CompanyCode,
      companyPersianName:
        data.CmpNam ?? data.companyPersianName ?? data.CompanyName,
      carGrpCod: data.CarGrpCod ?? data.carGrpCod,
      usgCod: data.UsgCod ?? data.usgCod,
      vehSysCod: data.VehSysCod ?? data.vehSysCod,
      mtrnum: data.MtrNum ?? data.mtrnum,
      shsNam: data.ShsNum ?? data.ShsNam ?? data.shsNam,
      vin: data.VIN ?? data.vin,
      ntnlId: data.NtnlId ?? data.ntnlId,
      fullname: data.InsNam ?? data.fullname,
      ThirdPolicyCode: data.PlcyUnqCod ?? data.ThirdPolicyCode,
      LastCompanyDocumentNumber:
        data.LastCmpDocNo ?? data.LastCompanyDocumentNumber,
      IssueDate: data.HIsuDte ?? data.IssueDate,
      StartDate: data.HBgnDte ?? data.StartDate,
      EndDate: data.HEndDte ?? data.EndDate,
      EdrsJson: data.Edrses ?? data.EdrsJson,
    });
  }

  /**
   * Normalises Jalali birth dates to `YYYY-MM-DD` for ESG person inquiry.
   * Unlike Tejarat/SandHub personal inquiry, ESG expects Jalali — not Gregorian.
   */
  private normalizeJalaliBirthDateForEsg(
    input: string | number | null | undefined,
  ): string | null {
    if (input === null || input === undefined) return null;

    const raw = typeof input === "number" ? String(input) : String(input).trim();
    if (!raw) return null;

    let year = 0;
    let month = 0;
    let day = 0;

    const separated = raw.match(/^(\d{4})[\-/](\d{1,2})[\-/](\d{1,2})$/);
    if (separated) {
      year = parseInt(separated[1], 10);
      month = parseInt(separated[2], 10);
      day = parseInt(separated[3], 10);
    } else {
      const digits = raw.replace(/\D/g, "");
      if (digits.length === 8) {
        year = parseInt(digits.slice(0, 4), 10);
        month = parseInt(digits.slice(4, 6), 10);
        day = parseInt(digits.slice(6, 8), 10);
      } else {
        return null;
      }
    }

    if (!year || !month || !day || year < 1300) return null;

    const mm = String(month).padStart(2, "0");
    const dd = String(day).padStart(2, "0");
    return `${year}-${mm}-${dd}`;
  }

  private getDefaultMockPersonInquiry(nationalCode: string): Record<string, unknown> {
    return {
      firstName: "نام",
      lastName: "خانوادگی",
      fatherName: "-",
      birthCertificateNumber: "-",
      nin: nationalCode,
    };
  }

  private mapEsgPersonInquiryToOldFormat(raw: any): Record<string, unknown> {
    if (raw?.success === false) {
      this.logger.warn("ESG person inquiry returned success=false", raw);
      throw new BadRequestException(
        SandHubService.ESG_INQUIRY_UNAVAILABLE_MESSAGE,
      );
    }

    const data = raw?.data ?? {};
    return {
      firstName: data.Name ?? data.firstName,
      lastName: data.Family ?? data.lastName,
      fatherName: data.FatherName ?? data.fatherName,
      birthCertificateNumber:
        data.Shenasnameserial ??
        data.ShenasnameNo ??
        data.birthCertificateNumber,
      nin: data.Nin ?? data.nationalCode ?? data.nin,
      fullName: data.fullName,
      birthDate: data.BirthDate ?? data.birthDate,
      gender: data.Gender,
      trackingCode: raw?.trackingCode,
    };
  }

  private mapEsgShebaInquiryToOldFormat(raw: any): Record<string, unknown> {
    if (raw?.success === false) {
      this.logger.warn("ESG sheba inquiry returned success=false", raw);
      throw new BadRequestException(
        SandHubService.ESG_INQUIRY_UNAVAILABLE_MESSAGE,
      );
    }

    const data = raw?.data ?? {};
    return {
      ReturnValue: data.ReturnValue ?? true,
      HasError: data.HasError ?? false,
      Errors: data.Errors ?? {},
      Message: raw?.message ?? data.Message,
      trackingCode: raw?.trackingCode,
    };
  }

  private async makeTejaratRequest(
    url: string,
    payload: any,
    inquiryType: ExternalInquiryType,
    options?: SandHubInquiryOptions,
    maxRetries = 2,
  ) {
    if (!(await this.isInquiryLive(inquiryType, options))) {
      this.logger.log(`[MOCK] Tejarat POST skipped (${inquiryType}): ${url}`);
      const ctx = await this.mockCompanyContext(options);
      return this.buildMockInquiryRaw(inquiryType, ctx, payload);
    }
    const INITIAL_DELAY = 500;
    const BACKOFF_FACTOR = 2;

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      const token = await this.getTejaratAccessToken();
      try {
        const response = await firstValueFrom(
          this.httpService.post(url, payload, {
            headers: {
              Authorization: `Bearer ${token}`,
              "Content-Type": "application/json",
              Accept: "application/json",
            },
            timeout: 30000,
          }),
        );
        if (!response?.data) throw new Error("EMPTY_RESPONSE");
        return response.data;
      } catch (err: any) {
        const status = err?.response?.status;
        const data = err?.response?.data;

        this.logger.error(
          `Tejarat request failed (attempt ${attempt + 1}/${maxRetries}) to ${url} with status ${
            status ?? "NO_STATUS"
          }`,
          data ? JSON.stringify(data) : err?.message || err,
        );

        // If unauthorized, clear token and retry once
        if (status === 401) {
          this.tejaratAccessToken = null;
          this.tejaratTokenExpiry = null;
        }

        const delay = INITIAL_DELAY * Math.pow(BACKOFF_FACTOR, attempt);
        await new Promise((resolve) => setTimeout(resolve, delay));
        if (attempt === maxRetries - 1) {
          throw err;
        }
      }
    }
  }

  /**
   * Tejarat block inquiry (replaces SandHub call for V2 flows).
   * Returns both raw + mapped (old-format) response.
   */
  async getTejaratBlockInquiry(
    userDetail: SandHubDetailDto,
    options?: SandHubInquiryOptions,
  ): Promise<{
    raw: any;
    mapped: any;
  }> {
    const ctx = await this.mockCompanyContext(options);
    if (this.shouldUseEsgInquiryProvider()) {
      const baseUrl = process.env.ESG_URL ?? "http://192.168.20.22:8085";
      const requestPayload = {
        nationalCode: String(userDetail.nationalCodeOfInsurer),
        plk1: String(userDetail.plate.leftDigits),
        plk2: String(userDetail.plate.centerAlphabet),
        plk3: String(userDetail.plate.centerDigits),
        plksrl: String(userDetail.plate.ir),
      };

      const requestUrl = `${baseUrl}/inquiry/policyByPlate`;
      const live = await this.isInquiryLive("thirdPartyPlate", options);
      const raw = live
        ? await this.makeEsgRequest(
            requestUrl,
            requestPayload,
            "thirdPartyPlate",
            options,
          )
        : this.buildMockPlateInquiryRaw(ctx);
      if (!live) {
        this.logger.debug(
          `[MOCK] getEsgPolicyByPlateInquiry plate=${JSON.stringify(requestPayload)}`,
        );
      }
      const mapped = this.mapEsgPolicyByPlateToOldFormat(raw);
      return { raw, mapped };
    }

    const baseUrl =
      process.env.TEJARAT_INQUIRY_BASE_URL ?? "http://82.99.202.245:3027";
    const requestPayload = {
      leftTwoDigits: String(userDetail.plate.leftDigits),
      serialLetter: String(userDetail.plate.centerAlphabet),
      threeDigits: String(userDetail.plate.centerDigits),
      rightTwoDigits: String(userDetail.plate.ir),
      nationalCode: userDetail.nationalCodeOfInsurer,
    };

    const requestUrl = `${baseUrl}/block-inquiry-tejarat`;
    const live = await this.isInquiryLive("thirdPartyPlate", options);
    const raw = live
      ? await this.makeTejaratRequest(
          requestUrl,
          requestPayload,
          "thirdPartyPlate",
          options,
        )
      : this.buildMockPlateInquiryRaw(ctx);
    if (!live) {
      this.logger.debug(
        `[MOCK] getTejaratBlockInquiry plate=${JSON.stringify(requestPayload)}`,
      );
    }
    const mapped = this.mapNewApiResponseToOldFormat(raw);
    return { raw, mapped };
  }

  async getSandHubDataFromId(sandHubId) {
    return await this.sandHubDbService.findOneBySandHubId(sandHubId);
  }

  async getTejaratCarBodyInquiry(
    userDetail: SandHubDetailDto,
    options?: SandHubInquiryOptions,
  ): Promise<{
    raw: any;
    mapped: Record<string, unknown>;
  }> {
    const baseUrl =
      process.env.TEJARAT_INQUIRY_BASE_URL ?? "http://82.99.202.245:3027";

    const requestPayload = {
      part1: Number(userDetail.plate.leftDigits),
      part2: String(userDetail.plate.centerAlphabet),
      part3: Number(userDetail.plate.centerDigits),
      part4: Number(userDetail.plate.ir),
      nationalCode: String(userDetail.nationalCodeOfInsurer),
    };

    const requestUrl = `${baseUrl}/block-inquiry-tejarat/badane`;
    const live = await this.isInquiryLive("carBodyPlate", options);
    if (!live) {
      this.logger.debug(
        `[MOCK] getTejaratCarBodyInquiry plate=${JSON.stringify(requestPayload)}`,
      );
    }

    const raw = await this.makeTejaratRequest(
      requestUrl,
      requestPayload,
      "carBodyPlate",
      options,
    );

    const mapped = this.mapCarBodyInquiryResponse(raw);
    return { raw, mapped };
  }

  /**
   * Maps the Tejarat car-body (badane) API response to a consistent
   * shape that mirrors the third-party inquiry mapped format.
   * Callers should always use `mapped` for display; `raw` is kept for audit.
   */
  private mapCarBodyInquiryResponse(raw: any): Record<string, unknown> {
    if (!raw) return {};

    const data = raw?.data ?? raw; // some responses nest under `data`

    return {
      // Identity
      policyNumber: data.printNumber ?? data.insuranceNumber ?? null,
      companyId: data.companyId ?? null,
      CompanyCode: data.companyId ?? null,
      CompanyName: data.companyName ?? data.companyPersianName ?? null,

      // Insurer
      insurerNationalCode:
        data.insurerNationalCode ?? data.ownerNationalCode ?? null,
      insurerName: data.insurerName ?? null,
      ownerNationalCode: data.ownerNationalCode ?? null,
      InsuranceFullName: data.insurerName ?? data.ownerName ?? null,

      // Vehicle
      motorNumber: data.motorNumber ?? data.EngineNumberField ?? null,
      EngineNumberField: data.motorNumber ?? data.EngineNumberField ?? null,
      chassisNumber: data.chassisNumber ?? data.ChassisNumberField ?? null,
      ChassisNumberField: data.chassisNumber ?? data.ChassisNumberField ?? null,
      vin: data.vin ?? data.VinNumberField ?? null,
      VinNumberField: data.vin ?? data.VinNumberField ?? null,
      vehicleGroupTitle: data.vehicleGroupTitle ?? null,
      vehicleSystemTitle: data.vehicleSystemTitle ?? null,
      MapTypNam: data.vehicleGroupTitle ?? data.vehicleSystemTitle ?? null,

      // Policy dates (Jalali strings from the API)
      IssueDate: data.issueDate ?? data.persianStartDate ?? null,
      StartDate: data.beginDate ?? data.persianStartDate ?? null,
      EndDate: data.endDate ?? data.persianEndDate ?? null,

      // Plate
      plateTypeTitle: data.plateTypeTitle ?? null,
      platePartOne: data.platePartOne ?? null,
      platePartThree: data.platePartThree ?? null,
      plateSerialNumber: data.plateSerialNumber ?? null,
      plateLetterTitle: data.plateLetterTitle ?? null,

      // Loss / no-claim history
      noLossYearsCount: data.noLossYearsCount ?? null,
      lossDocuments: Array.isArray(data.lossDocuments)
        ? data.lossDocuments
        : [],

      // Misc
      hasEndorsement: data.hasEndorsement ?? null,
      previousId: data.previousId ?? null,

      // Status passthrough
      isSuccess: raw?.isSuccess ?? true,
      statusCode: raw?.statusCode ?? 200,
      message: raw?.message ?? null,
    };
  }

  private async makeSandHubRequest(
    url: string,
    payload: any,
    inquiryType: ExternalInquiryType,
    options?: SandHubInquiryOptions,
    maxRetries = 3,
  ) {
    if (!(await this.isInquiryLive(inquiryType, options))) {
      this.logger.log(`[MOCK] SandHub POST skipped (${inquiryType}): ${url}`);
      const ctx = await this.mockCompanyContext(options);
      if (inquiryType === "carBodyPlate") {
        return this.buildMockInquiryRaw(inquiryType, ctx, payload);
      }
      const plateMock =
        inquiryType === "thirdPartyPlate"
          ? this.buildMockPlateInquiryRaw(ctx)
          : undefined;
      return this.buildMockSandHubResponseForUrl(url, payload, plateMock);
    }
    const token = await this.getAccessToken();
    const INITIAL_DELAY = 1000;
    const BACKOFF_FACTOR = 2;

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      try {
        const response = await firstValueFrom(
          this.httpService.post(url, payload, {
            headers: {
              Authorization: `Bearer ${token}`,
              "Content-Type": "application/json",
              Accept: "application/json",
            },
            timeout: 50000,
          }),
        );
        if (!response?.data) throw new Error("EMPTY_RESPONSE");
        return response.data;
      } catch (err) {
        this.handleSandHubError(err, attempt, maxRetries);
        const delay = INITIAL_DELAY * Math.pow(BACKOFF_FACTOR, attempt);
        await new Promise((resolve) => setTimeout(resolve, delay));
      }
    }
    throw new BadGatewayException(
      "Failed to fetch data from SandHub after multiple retries",
    );
  }

  /**
   * Maps the new SandHub API response format to the old format expected by the application
   */
  private mapNewApiResponseToOldFormat(newResponse: any): any {
    if (!newResponse) return newResponse;

    // Map the new field names to the old field names
    return {
      ...newResponse,
      // Company information
      CompanyCode: newResponse.companyId || newResponse.CompanyCode,
      CompanyName: newResponse.companyPersianName || newResponse.CompanyName,

      // Vehicle information
      MapTypNam: newResponse.vehiclePersianName || newResponse.MapTypNam,
      UsageField:
        newResponse.persianCarType ||
        newResponse.UsageField ||
        (newResponse.usgCod === "8" ? "شخصی" : "نامشخص"),
      MapUsageName: newResponse.MapUsageName || newResponse.MapUsageName,

      // Financial coverage
      FinancialCvrCptl:
        newResponse.financeCoverage || newResponse.FinancialCvrCptl || "0",

      // Dates
      IssueDate: newResponse.persianStartDate || newResponse.IssueDate,
      EndDate: newResponse.persianEndDate || newResponse.EndDate,

      // Insurance details
      LastCompanyDocumentNumber:
        newResponse.lastCompanyInsuranceNumber ||
        newResponse.LastCompanyDocumentNumber ||
        newResponse.insuranceNumber,

      // Technical details
      MtrNum: newResponse.MtrNum || newResponse.mtrnum,
      ShsNum:
        newResponse.ShsNum ||
        newResponse.shsNam ||
        newResponse.ChassisNumberField,
      vin: newResponse.vin || newResponse.VinNumberField || newResponse.vin,
      VinNumberField: newResponse.vin || newResponse.VinNumberField,
      ChassisNumberField: newResponse.ChassisNumberField || newResponse.shsNam,
      EngineNumberField: newResponse.EngineNumberField || newResponse.mtrnum,
      ModelField: newResponse.ModelField || newResponse.ModelField,

      // Discount information
      DisFnYrPrcnt: newResponse.DisFnYrPrcnt || newResponse.disFnYrPrcnt || "0",
      DisLfYrPrcnt: newResponse.DisLfYrPrcnt || newResponse.disLfYrPrcnt || "0",
      DisPrsnYrPrcnt:
        newResponse.DisPrsnYrPrcnt || newResponse.disPrsnYrPrcnt || "0",
      DisFnYrNum: newResponse.DisFnYrNum || newResponse.disFnYrNum,
      DisLfYrNum: newResponse.DisLfYrNum || newResponse.disLfYrNum,
      DisPrsnYrNum: newResponse.DisPrsnYrNum || newResponse.disPrsnYrNum,

      // Usage and vehicle system codes
      UsageCode: newResponse.UsageCode || newResponse.usgCod,
      VehicleSystemCode: newResponse.VehicleSystemCode || newResponse.vehSysCod,
      CarGroupCode: newResponse.CarGroupCode || newResponse.carGrpCod,

      // Policy information
      ThirdPolicyCode:
        newResponse.ThirdPolicyCode || newResponse.ThirdPolicyCode,

      // Endorsement data
      EdrsJson:
        newResponse.EdrsJson ||
        (newResponse.edrSes ? JSON.stringify(newResponse.edrSes) : undefined),

      // Insurance fullname
      InsuranceFullName: newResponse.InsuranceFullName || newResponse.fullname,

      // National code
      nationalCode: newResponse.nationalCode || newResponse.ntnlId,
    };
  }

  async getSandHubResponse(
    userDetail: SandHubDetailDto,
    options?: SandHubInquiryOptions,
  ) {
    try {
      const requestPayload = {
        leftTwoDigits: String(userDetail.plate.leftDigits),
        serialLetter: String(userDetail.plate.centerAlphabet),
        threeDigits: String(userDetail.plate.centerDigits),
        rightTwoDigits: String(userDetail.plate.ir),
        nationalCode: userDetail.nationalCodeOfInsurer,
      };
      const base = process.env.SANHUB_BASE_URL ?? "";
      const requestUrl = `${base}/block-inquiry-tejarat`;

      let response: any;
      if (await this.isInquiryLive("thirdPartyPlate", options)) {
        response = await this.makeSandHubRequest(
          requestUrl,
          requestPayload,
          "thirdPartyPlate",
          options,
        );
      } else {
        this.logger.debug(
          `[MOCK] getSandHubResponse plate=${JSON.stringify(requestPayload)}`,
        );
        const ctx = await this.mockCompanyContext(options);
        response = this.buildMockPlateInquiryRaw(ctx);
      }

      const result = this.mapNewApiResponseToOldFormat(response);

      // if (result.usgCod !== "8") {
      //   throw new Error("خودرو شما شخصی / سواری نمی باشد")
      // }

      return result;
    } catch (err) {
      throw new Error(err);
    }
  }

  /**
   * Personal identity check.
   * - CLIENT_ID=8 (Parsian/ESG): Jalali birth date sent as-is to `/inquiry/person`.
   * - Other tenants: Tejarat/SandHub hub with Gregorian conversion.
   */
  async getPersonalInquiry(
    nationalCode: string,
    birthDate: number | string,
    options?: SandHubInquiryOptions,
  ) {
    try {
      if (this.shouldUseEsgInquiryProvider()) {
        const jalaliBirthDate = this.normalizeJalaliBirthDateForEsg(birthDate);
        if (!jalaliBirthDate) {
          throw new BadRequestException(
            `Invalid birth date for personal inquiry: ${birthDate}. Expected a Jalali date (e.g. 13781124 or "1378-11-24").`,
          );
        }

        const baseUrl = process.env.ESG_URL ?? "http://192.168.20.22:8085";
        const requestPayload = {
          nationalCode: String(nationalCode),
          birthDate: jalaliBirthDate,
          dateHasPostfix: 0,
        };
        const requestUrl = `${baseUrl}/inquiry/person`;
        const live = await this.isInquiryLive("personalIdentity", options);

        if (!live) {
          this.logger.debug(
            `[MOCK] getEsgPersonInquiry nationalCode=${nationalCode} birthDate=${jalaliBirthDate}`,
          );
          return this.getDefaultMockPersonInquiry(String(nationalCode));
        }

        const raw = await this.makeEsgRequest(
          requestUrl,
          requestPayload,
          "personalIdentity",
          options,
        );
        return this.mapEsgPersonInquiryToOldFormat(raw);
      }

      const requestUrl = `${process.env.SANHUB_BASE_URL}/personal-inquiry/tejarat-no`;

      const gregorianBirthdate = jalaliToGregorianDate(birthDate);
      if (!gregorianBirthdate) {
        throw new BadRequestException(
          `Invalid birth date for personal inquiry: ${birthDate}. Expected a Jalali date (e.g. 13770624 or "1377-06-24").`,
        );
      }

      const requestPayload = {
        nationalCode,
        birthdate: gregorianBirthdate,
      };

      const response = await this.makeSandHubRequest(
        requestUrl,
        requestPayload,
        "personalIdentity",
        options,
      );

      if (response?.message?.includes("err.record.not.found")) {
        throw new NotFoundException(
          "Personal inquiry failed: Record not found for the given national code and birth date.",
        );
      }
      return response.data;
    } catch (err) {
      if (
        err instanceof BadRequestException ||
        err instanceof NotFoundException
      ) {
        throw err;
      }
      throw new Error(`Error in finding personal inquiry: ${err}`);
    }
  }

  async getDrivingLicenseInfo(
    nationalCode: string,
    driverLicenseNumber: string,
    options?: SandHubInquiryOptions,
  ) {
    const requestUrl = `${process.env.SANHUB_BASE_URL}/driver-license-check`;
    const requestPayload = {
      driverLicenseNumber,
      nationalCode,
    };

    this.logger.log(
      `Fetching driving license info for national code: ${nationalCode}`,
    );

    try {
      const response = await this.makeSandHubRequest(
        requestUrl,
        requestPayload,
        "drivingLicense",
        options,
      );

      if (response?.data?.IsSucceed === false) {
        throw new NotFoundException(
          "Driving license check failed: The license is not valid or could not be found.",
        );
      }

      return response.data;
    } catch (error) {
      if (
        error instanceof BadGatewayException &&
        error.message.includes("multiple retries")
      ) {
        throw new BadGatewayException(
          `Driving license check failed after multiple retries. The service may be down.`,
        );
      }
      // For all other errors (like 400, 404, etc.), re-throw them as-is.
      throw new Error(`Error in finding driving license: ${error}`);
    }
  }

  async getCarOwnershipInfo(
    plate: any,
    nationalCode: string,
    options?: SandHubInquiryOptions,
  ) {
    try {
      const requestUrl = `${process.env.SANHUB_BASE_URL}/ownership`;
      const requestPayload = {
        Plk1: String(plate.leftDigits),
        Plk2: String(plate.centerAlphabet),
        Plk3: String(plate.centerDigits),
        plkSrl: String(plate.ir),
        nationalCode: nationalCode,
      };

      this.logger.log(
        `Checking car ownership for national code: ${nationalCode}`,
      );
      const response = await this.makeSandHubRequest(
        requestUrl,
        requestPayload,
        "carOwnership",
        options,
      );

      // Check the 'IsSuccess' field in the nested 'data' object.
      if (response?.data?.IsSuccess === false) {
        this.logger.warn(
          `Car ownership check failed for national code ${nationalCode}. Response:`,
          response,
        );
        throw new BadRequestException(
          "Ownership validation failed: The provided national ID is not the owner of this vehicle.",
        );
      }

      return response;
    } catch (err) {
      throw new Error(`Error in finding car ownership: ${err}`);
    }
  }

  async getShebaValidation(
    nationalId: string,
    shebaId: string,
    options?: SandHubInquiryOptions,
  ) {
    try {
      if (this.shouldUseEsgInquiryProvider()) {
        const baseUrl = process.env.ESG_URL ?? "http://192.168.20.22:8085";
        const requestPayload = {
          accountOwnerType: "1",
          nationalCode: String(nationalId),
          legalId: "",
          sheba: String(shebaId),
        };
        const requestUrl = `${baseUrl}/inquiry/sheba`;
        const live = await this.isInquiryLive("sheba", options);

        this.logger.log(
          `Validating Sheba ID via ESG for national code: ${nationalId}`,
        );

        if (!live) {
          this.logger.debug(
            `[MOCK] getEsgShebaInquiry nationalCode=${nationalId} sheba=${shebaId}`,
          );
          return {
            ReturnValue: true,
            HasError: false,
            Message: "mock-sheba-ok",
          };
        }

        const raw = await this.makeEsgRequest(
          requestUrl,
          requestPayload,
          "sheba",
          options,
        );
        const response = this.mapEsgShebaInquiryToOldFormat(raw);

        if (response?.ReturnValue === false || response?.HasError === true) {
          this.logger.warn(
            `Sheba validation failed for national code ${nationalId}. Response:`,
            response,
          );
          throw new BadRequestException(
            "Sheba ID validation failed. The provided Sheba ID does not match the national ID.",
          );
        }

        return response;
      }

      const requestUrl = `${process.env.SANHUB_BASE_URL}/sheba/sheba-tejaratno`;
      const requestPayload = {
        AccountOwnerType: "1",
        NationalId: nationalId,
        ShebaId: shebaId,
      };

      this.logger.log(`Validating Sheba ID for national code: ${nationalId}`);
      const response = await this.makeSandHubRequest(
        requestUrl,
        requestPayload,
        "sheba",
        options,
      );

      if (response?.ReturnValue === false || response?.HasError === true) {
        this.logger.warn(
          `Sheba validation failed for national code ${nationalId}. Response:`,
          response,
        );
        throw new BadRequestException(
          "Sheba ID validation failed. The provided Sheba ID does not match the national ID.",
        );
      }

      return response;
    } catch (err) {
      if (err instanceof BadRequestException) {
        throw err;
      }
      throw new Error(`Error in matching sheba validation: ${err}`);
    }
  }

  private handleSandHubError(
    err: any,
    attempt: number,
    maxRetries: number,
  ): void {
    if (err.response) {
      this.logger.error(
        `❌ SandHub responded with status ${err.response.status} on attempt ${attempt + 1}:`,
        JSON.stringify(err.response.data),
      );

      if (err.response.status === 400) {
        throw new BadGatewayException(
          `SandHub rejected the request with a 400 Bad Request. Details: ${JSON.stringify(err.response.data)}`,
        );
      }
    } else {
      this.logger.error(
        `❌ Network error during SandHub request (attempt ${attempt + 1}):`,
        err.message,
      );
    }

    if (err.message === "EMPTY_RESPONSE") {
      throw new BadGatewayException(
        "SandHub is offline or returned an empty response",
      );
    }
    if (err.code === "ECONNABORTED") {
      throw new GatewayTimeoutException("SandHub request timed out");
    }
    if (err.code === "ECONNRESET" || err.message.includes("socket hang up")) {
      throw new ServiceUnavailableException(
        "SandHub connection was reset or closed unexpectedly",
      );
    }

    // This final check is for when all retries have failed for a retryable error.
    if (attempt >= maxRetries) {
      throw new BadGatewayException(
        "Failed to fetch data from SandHub after multiple retries",
        err.message,
      );
    }
  }

  async sandHubDocumentCreator(
    userId: string,
    requestId: string,
    doc: Partial<SandHubModel>,
  ) {
    const existingDoc = await this.sandHubDbService.findOneByRequestId(
      requestId,
      userId,
    );
    if (!existingDoc) {
      return await this.sandHubDbService.create({ ...doc, userId, requestId });
    } else {
      const updatePayload = { ...existingDoc, ...doc };
      return await this.sandHubDbService.findOneByRequestIdAndUpdate(
        requestId,
        userId,
        updatePayload,
      );
    }
  }
}