var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/modules/Payment/walletpass.ts
var walletpass_exports = {};
__export(walletpass_exports, {
  WalletPassPaymentImpl: () => WalletPassPaymentImpl
});
module.exports = __toCommonJS(walletpass_exports);
var import_types = require("./types");
var import_utils = require("./utils");
var WalletPassPaymentImpl = class {
  constructor(paymentModule) {
    this.paymentModule = paymentModule;
    this.walletRecommendList = [];
    this.userIdentificationCodes = [];
    this.searchResults = [];
    this.walletParams = null;
    this.walletInitData = null;
  }
  /**
   * 发送事件的辅助方法
   * 支持使用WalletPassHooks或PaymentHooks
   */
  emitEvent(hook, data) {
    try {
      const eventName = hook.split(":")[1] || hook.replace(/^[A-Z][a-z]+/, "").replace(/^On/, "").toLowerCase();
      const fullEventName = `${this.paymentModule.name}:${eventName}`;
      this.paymentModule.core.effects.emit(fullEventName, data);
    } catch (error) {
      this.paymentModule.logError("[WalletPass] 发送事件失败", error, {
        hook
      });
    }
  }
  /**
   * 生成钱包API默认参数
   * 根据业务数据生成标准的钱包API参数，并存储在模块中
   */
  generateWalletParams(businessData) {
    var _a, _b;
    const {
      customer_id,
      holder,
      amountInfo,
      products,
      order_wait_pay_amount,
      payment_order_id,
      is_price_include_tax
    } = businessData;
    const totalAmount = Number(amountInfo.totalAmount);
    const subTotal = Number(amountInfo.subTotal);
    const walletParams = {
      is_price_include_tax,
      sale_channel: "pos",
      customer_id: customer_id || 0,
      // 提供默认值，确保类型为 number
      holder_id: ((_a = holder == null ? void 0 : holder.form_record) == null ? void 0 : _a[0]) || void 0,
      order_expect_amount: totalAmount,
      // 订单小计金额
      order_product_amount: subTotal,
      // 订单待支付金额
      order_wait_pay_amount: order_wait_pay_amount || ((amountInfo == null ? void 0 : amountInfo.isDeposit) ? Number(amountInfo == null ? void 0 : amountInfo.depositAmount) : totalAmount),
      // order_behavior_count_customer_id: 1,
      products,
      prepare_payments: [],
      payment_order_id
    };
    this.walletParams = walletParams;
    this.paymentModule.logInfo("[WalletPass] 钱包默认参数已生成并存储", {
      customer_id: walletParams.customer_id,
      holder_id: walletParams.holder_id,
      order_expect_amount: walletParams.order_expect_amount,
      order_product_amount: walletParams.order_product_amount,
      order_wait_pay_amount: walletParams.order_wait_pay_amount,
      products_count: ((_b = walletParams.products) == null ? void 0 : _b.length) || 0
    });
    this.walletInitData = {
      transformList: [],
      noApplicableVoucher: [],
      products: products || []
    };
    return walletParams;
  }
  /**
   * 获取已存储的钱包参数
   * 返回之前生成并存储的钱包参数
   */
  getStoredWalletParams() {
    return this.walletParams;
  }
  /**
   * 清理已存储的钱包参数
   * 清除之前存储的钱包参数
   */
  clearStoredWalletParams() {
    this.walletParams = null;
    this.paymentModule.logInfo("[WalletPass] 已存储的钱包参数已清理");
  }
  /**
   * 从业务数据初始化钱包数据
   * 内部生成参数，然后调用标准的初始化流程
   */
  async initializeWalletDataFromBusinessAsync(businessData) {
    var _a, _b, _c, _d, _e, _f, _g, _h;
    const startTime = Date.now();
    const walletParams = this.generateWalletParams(businessData);
    if (Number(((_a = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _a.totalAmount) || 0) < 0 || Number(((_b = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _b.subTotal) || 0) < 0) {
      return {
        walletRecommendList: [],
        userIdentificationCodes: [],
        transformList: [],
        noApplicableVoucher: [],
        products: []
      };
    }
    if ([1, 0].includes((walletParams == null ? void 0 : walletParams.customer_id) || 0)) {
      return {
        walletRecommendList: [],
        userIdentificationCodes: []
      };
    }
    this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationStarted, {
      businessData,
      startTime
    });
    this.paymentModule.logInfo("[WalletPass] 开始从业务数据初始化钱包数据", {
      customer_id: businessData.customer_id,
      totalAmount: (_c = businessData.amountInfo) == null ? void 0 : _c.totalAmount,
      subTotal: (_d = businessData.amountInfo) == null ? void 0 : _d.subTotal,
      order_wait_pay_amount: businessData.order_wait_pay_amount,
      products_count: ((_e = businessData.products) == null ? void 0 : _e.length) || 0
    });
    try {
      const result = await this.initializeWalletDataAsync(walletParams);
      const endTime = Date.now();
      const duration = endTime - startTime;
      this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationCompleted, {
        businessData,
        result,
        startTime,
        endTime,
        duration
      });
      this.paymentModule.logInfo(`[WalletPass] 从业务数据初始化钱包数据成功`, {
        duration: `${duration}ms`,
        walletRecommendList_count: ((_f = result.walletRecommendList) == null ? void 0 : _f.length) || 0,
        userIdentificationCodes_count: ((_g = result.userIdentificationCodes) == null ? void 0 : _g.length) || 0
      });
      return result;
    } catch (error) {
      const endTime = Date.now();
      const duration = endTime - startTime;
      this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationFailed, {
        businessData,
        error,
        startTime,
        endTime,
        duration
      });
      this.paymentModule.logError(
        `[WalletPass] 从业务数据初始化钱包数据失败`,
        error,
        {
          duration: `${duration}ms`,
          customer_id: businessData.customer_id,
          totalAmount: (_h = businessData.amountInfo) == null ? void 0 : _h.totalAmount
        }
      );
      throw error;
    }
  }
  /**
   * 获取订单基础详情
   */
  async getOrderBasicDetailAsync(orderId) {
    try {
      const response = await this.paymentModule.request.get(
        `/order/order/${orderId}/basic-detail`
      );
      return (response == null ? void 0 : response.data) || {};
    } catch (error) {
      throw error;
    }
  }
  /**
   * 初始化钱包数据
   * 先获取推荐列表，再获取用户识别码列表（顺序执行）
   */
  async initializeWalletDataAsync(baseParams) {
    var _a, _b;
    try {
      const identificationParams = {
        ...baseParams,
        available: 2,
        prepare_payments: [],
        other_exact_codes: [],
        filter_prepare_wallet_pass: 1
      };
      const [allList, orderBasicDetail] = await Promise.all([
        this.getUserIdentificationCodeListAsync(identificationParams),
        baseParams.payment_order_id ? this.getOrderBasicDetailAsync(baseParams.payment_order_id) : Promise.resolve(null)
      ]);
      const walletPassEvaluator = (_b = (_a = this.paymentModule.window) == null ? void 0 : _a.getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
      if (!walletPassEvaluator) {
        return {
          walletRecommendList: [],
          userIdentificationCodes: [],
          transformList: [],
          noApplicableVoucher: [],
          products: []
        };
      }
      const products = (orderBasicDetail == null ? void 0 : orderBasicDetail.detail) || baseParams.products;
      const res = walletPassEvaluator == null ? void 0 : walletPassEvaluator.getRecommendedVouchers({
        orderTotalAmount: baseParams.order_wait_pay_amount,
        products,
        vouchers: allList
      });
      const { recommended, transformList, noApplicableVoucher, recommendedAmount } = res;
      console.log(res, "resres12");
      this.walletRecommendList = recommended;
      this.walletInitData = {
        transformList,
        noApplicableVoucher,
        products: products || []
      };
      return {
        walletRecommendList: recommended,
        userIdentificationCodes: allList,
        transformList,
        noApplicableVoucher,
        products: products || []
      };
    } catch (error) {
      this.paymentModule.logError("[WalletPass] 初始化钱包数据失败", error, {
        customer_id: baseParams.customer_id,
        order_expect_amount: baseParams.order_expect_amount
      });
      throw error;
    }
  }
  async getWalletPassRecommendListAsync(params) {
    var _a;
    try {
      this.paymentModule.logInfo("[WalletPass] 开始获取钱包推荐列表", {
        customer_id: params.customer_id,
        order_expect_amount: params.order_expect_amount,
        sale_channel: params.sale_channel,
        payment_order_id: (_a = this.walletParams) == null ? void 0 : _a.payment_order_id
      });
      const response = await this.paymentModule.request.post(
        "/machinecode/prepare/deduction/recommend",
        params
        // 将 params 作为请求体数据
      );
      this.walletRecommendList = (response == null ? void 0 : response.data) || [];
      this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListUpdated, {
        walletRecommendList: this.walletRecommendList
      });
      this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已更新", {
        count: this.walletRecommendList.length,
        items: this.walletRecommendList.map((item) => ({
          voucher_id: item.voucher_id,
          name: item.name,
          amount: item.amount,
          tag: item.tag
        }))
      });
      return this.walletRecommendList;
    } catch (error) {
      this.paymentModule.logError("[WalletPass] 获取钱包推荐列表失败", error, {
        customer_id: params.customer_id,
        order_expect_amount: params.order_expect_amount,
        sale_channel: params.sale_channel
      });
      return [];
    }
  }
  formatWalletPassList2PreparePayments(list) {
    return (0, import_utils.formatWalletPassList2PreparePayments)(list);
  }
  async getUserIdentificationCodeListAsync(params) {
    var _a, _b;
    try {
      const newParams = {
        ...this.walletParams,
        ...params
      };
      this.paymentModule.logInfo("[WalletPass] 开始获取用户识别码列表", {
        customer_id: newParams.customer_id,
        available: newParams.available,
        prepare_payments_count: ((_a = newParams.prepare_payments) == null ? void 0 : _a.length) || 0,
        filter_prepare_wallet_pass: newParams.filter_prepare_wallet_pass,
        payment_order_id: (_b = this.walletParams) == null ? void 0 : _b.payment_order_id
      });
      const response = await this.paymentModule.request.post(
        "/machinecode/prepare/deduction",
        newParams
      );
      const sortedData = (0, import_utils.sortUserIdentificationCodeList)((response == null ? void 0 : response.data) || []);
      this.userIdentificationCodes = sortedData;
      this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
        userIdentificationCodes: this.userIdentificationCodes
      });
      this.paymentModule.logInfo("[WalletPass] 用户识别码列表已更新", {
        count: this.userIdentificationCodes.length,
        sorted_items: this.userIdentificationCodes.slice(0, 5).map((item) => ({
          code: item.code,
          error_code: item.error_code,
          error_msg: item.error_msg
        }))
      });
      return this.userIdentificationCodes;
    } catch (error) {
      this.paymentModule.logError(
        "[WalletPass] 获取用户识别码列表失败",
        error,
        {
          customer_id: params.customer_id,
          available: params.available
        }
      );
      return [];
    }
  }
  /**
   * 搜索识别码信息
   * 通过识别码搜索相关的钱包通行证信息
   * 基于 WalletDeductionRecommendParams 参数结构
   * 特殊逻辑：当识别码长度为9位且前3位为"000"时，调用 /wallet/detail/search 接口
   */
  async searchIdentificationCodeAsync(params, config = {}) {
    var _a;
    try {
      const { code } = params;
      this.paymentModule.logInfo("[WalletPass] 开始搜索识别码", {
        code,
        code_length: code.length,
        noCache: config.noCache || false
      });
      const isWalletCode = code.startsWith("WL") || code.startsWith("200") && code.length === 10;
      if (isWalletCode) {
        const walletDetailParams = {
          code,
          with_customer: 1,
          with: ["wallet"]
        };
        this.paymentModule.logInfo("[WalletPass] 搜索钱包识别码", {
          code,
          with_customer: walletDetailParams.with_customer,
          with: walletDetailParams.with
        });
        const response2 = await this.paymentModule.request.post(
          "/wallet/detail/search",
          walletDetailParams
        );
        const searchResults2 = (response2 == null ? void 0 : response2.data) || [];
        this.paymentModule.logInfo("[WalletPass] 钱包识别码搜索完成", {
          code,
          results_count: searchResults2.length,
          type: "walletCode"
        });
        return {
          type: "walletCode",
          data: searchResults2
        };
      }
      const baseWalletParams = this.walletParams;
      const searchParams = {
        // 基础钱包参数
        sale_channel: params.sale_channel || (baseWalletParams == null ? void 0 : baseWalletParams.sale_channel) || "pos",
        customer_id: params.customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.customer_id),
        order_expect_amount: params.order_expect_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_expect_amount),
        order_product_amount: params.order_product_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_product_amount),
        order_wait_pay_amount: params.order_wait_pay_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_wait_pay_amount),
        order_behavior_count_customer_id: params.order_behavior_count_customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.order_behavior_count_customer_id) || params.customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.customer_id),
        products: params.products || (baseWalletParams == null ? void 0 : baseWalletParams.products),
        prepare_payments: params.prepare_payments || (baseWalletParams == null ? void 0 : baseWalletParams.prepare_payments),
        multiple: 1,
        // 搜索特有参数
        code: params.code,
        payment_order_id: baseWalletParams == null ? void 0 : baseWalletParams.payment_order_id
      };
      this.paymentModule.logInfo("[WalletPass] 搜索普通识别码", {
        code: searchParams.code,
        customer_id: searchParams.customer_id,
        order_expect_amount: searchParams.order_expect_amount,
        multiple: searchParams.multiple,
        payment_order_id: baseWalletParams == null ? void 0 : baseWalletParams.payment_order_id
      });
      let response;
      if (!searchParams.products || ((_a = searchParams.products || []) == null ? void 0 : _a.length) === 0) {
        response = {
          data: []
        };
      } else {
        response = await this.paymentModule.request.post(
          "/machinecode/prepare/deduction/search",
          searchParams
        );
      }
      const searchResults = (response == null ? void 0 : response.data) || [];
      if (config.noCache) {
        return {
          type: "normalCode",
          data: searchResults
        };
      }
      if (searchResults.length > 0) {
        const existingCodes = new Set(
          this.searchResults.map((item) => item.code)
        );
        const newResults = searchResults.filter(
          (item) => !existingCodes.has(item.code)
        );
        this.searchResults.push(...newResults);
      }
      this.emitEvent(import_types.WalletPassHooks.OnSearchIdentificationCodeCompleted, {
        searchCode: params.code,
        currentSearchResults: searchResults,
        cachedSearchResults: [...this.searchResults],
        searchParams: params
      });
      this.paymentModule.logInfo("[WalletPass] 普通识别码搜索完成", {
        code: params.code,
        results_count: searchResults.length,
        cached_results_count: this.searchResults.length,
        type: "normalCode"
      });
      return {
        type: "normalCode",
        data: searchResults
      };
    } catch (error) {
      this.paymentModule.logError("[WalletPass] 搜索识别码信息失败", error, {
        code: params.code,
        customer_id: params.customer_id,
        order_expect_amount: params.order_expect_amount
      });
      throw error;
    }
  }
  async processWalletPayment(amount, orderUuid, voucherId) {
    this.paymentModule.logInfo("[WalletPass] 开始处理钱包支付", {
      amount,
      orderUuid,
      voucherId: voucherId || "none"
    });
    const walletMethod = await this.paymentModule.getWalletPaymentMethod();
    if (!walletMethod) {
      this.paymentModule.logError("[WalletPass] 钱包支付方式未找到", null, {
        amount,
        orderUuid,
        voucherId
      });
      throw new Error("钱包支付方式未找到");
    }
    const paymentItem = {
      amount: amount.toString(),
      code: walletMethod.code,
      custom_payment_id: walletMethod.id,
      name: walletMethod.name,
      type: walletMethod.type,
      voucher_id: voucherId || ""
    };
    await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
    this.paymentModule.logInfo("[WalletPass] 钱包支付处理完成", {
      amount,
      orderUuid,
      voucherId: voucherId || "none",
      payment_method: walletMethod.name
    });
  }
  async getWalletBalance(voucherId) {
    return 0;
  }
  /**
   * 获取缓存的钱包推荐列表
   */
  getWalletRecommendList() {
    return this.walletRecommendList;
  }
  /**
   * 获取缓存的用户识别码列表
   */
  getUserIdentificationCodes() {
    return this.userIdentificationCodes;
  }
  /**
   * 清除钱包推荐列表
   */
  clearWalletRecommendList() {
    this.walletRecommendList = [];
    this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListCleared, {
      clearedTypes: ["walletRecommendList"]
    });
    this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已清除");
  }
  /**
   * 清除用户识别码列表
   */
  clearUserIdentificationCodes() {
    this.userIdentificationCodes = [];
    this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesCleared, {
      clearedTypes: ["userIdentificationCodes"]
    });
    this.paymentModule.logInfo("[WalletPass] 用户识别码列表已清除");
  }
  /**
   * 获取缓存的搜索结果列表
   */
  getSearchResults() {
    return this.searchResults;
  }
  /**
   * 根据识别码查找搜索结果
   */
  findSearchResultByCode(code) {
    return this.searchResults.find((item) => item.code === code);
  }
  /**
   * 清除搜索结果缓存
   */
  clearSearchResults() {
    this.searchResults = [];
    this.paymentModule.logInfo("[WalletPass] 搜索结果缓存已清除");
  }
  /**
   * 获取存储的钱包初始化数据
   */
  getStoredWalletInitData() {
    return this.walletInitData;
  }
  /**
   * 清除存储的钱包初始化数据
   */
  clearStoredWalletInitData() {
    this.walletInitData = null;
    this.paymentModule.logInfo("[WalletPass] 钱包初始化数据已清除");
  }
  /**
   * 清除所有缓存数据
   */
  clearAllCache() {
    this.walletRecommendList = [];
    this.userIdentificationCodes = [];
    this.searchResults = [];
    this.walletParams = null;
    this.walletInitData = null;
    this.emitEvent(import_types.WalletPassHooks.OnWalletCacheCleared, {
      clearedTypes: ["all"]
    });
    this.paymentModule.logInfo("[WalletPass] 所有缓存数据已清除", {
      cleared_types: [
        "walletRecommendList",
        "userIdentificationCodes",
        "searchResults",
        "walletParams",
        "walletInitData"
      ]
    });
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  WalletPassPaymentImpl
});
