gubersail-platform-ui/src/components/forecast-form/forecast-form-mixin.js

// @ts-check
/* global BigInt */

/**
 * @fileoverview 销售预测表单混入组件
 * @description 提供销售预测表单的数据管理、验证规则和业务逻辑的混入组件，支持新增和编辑模式
 * @this {ForecastFormMixinComponent & Vue}
 */

/**
 * 类型定义导入
 * @description 导入所有必要的TypeScript类型定义，确保类型安全
 */

/**
 * @typedef {import('./types').ForecastFormModel} ForecastFormModel
 * @description 销售预测表单数据模型类型
 */

/**
 * @typedef {import('./types').ForecastFormMixinData} ForecastFormMixinData
 * @description 销售预测表单混入数据类型
 */

/**
 * @typedef {import('./types').CustomerOption} CustomerOption
 * @description 客户选项类型
 */

/**
 * @typedef {import('./types').ItemOption} ItemOption
 * @description 物料选项类型
 */

/**
 * @typedef {import('./types').ApprovalStatusOption} ApprovalStatusOption
 * @description 审批状态选项类型
 */

/**
 * @typedef {import('./types').ForecastFormRules} ForecastFormRules
 * @description 销售预测表单验证规则类型
 */

/**
 * @typedef {import('./types').MaterialSelectData} MaterialSelectData
 * @description 物料选择数据类型
 */

/**
 * @typedef {import('./types').CustomerSelectData} CustomerSelectData
 * @description 客户选择数据类型
 */

/**
 * @typedef {import('./types').ForecastFormMixinComponent} ForecastFormMixinComponent
 * @description 销售预测表单混入组件类型
 */

// API接口导入
import { addForecast, updateForecast, getForecastDetail } from '@/api/forecast'
import { addSalesForecastMain, updateSalesForecastMain, getSalesForecastSummaryByMonth } from '@/api/forecast/forecast-summary'
import { getUserLinkGoods } from '@/api/order/sales-order'

// 常量和枚举导入
import {
  APPROVAL_STATUS,
  APPROVAL_STATUS_OPTIONS,
  FORECAST_FORM_RULES,
  DEFAULT_FORECAST_FORM,
  getApprovalStatusLabel,
  getApprovalStatusType,
  canEdit
} from '@/constants/forecast'

// 远程搜索API
import { getCustomerList, getItemList, getCustomerInfo } from '@/api/common'

// 表单配置导入
import { getFormOption } from './form-option'
import { safeBigInt } from '@/util/util'

/**
 * 销售预测表单事件常量
 * @readonly
 */
export const FORECAST_FORM_EVENTS = {
  /** 表单提交成功事件 */
  SUBMIT_SUCCESS: 'submit-success',
  /** 表单取消事件 */
  CANCEL: 'cancel',
  /** 表单加载完成事件 */
  LOADED: 'loaded',
  /** 客户选择变更事件 */
  CUSTOMER_CHANGE: 'customer-change',
  /** 物料选择变更事件 */
  ITEM_CHANGE: 'item-change',
  /** 表单重置事件 */
  RESET: 'reset',
  /** 表单提交事件 */
  SUBMIT: 'submit',
  /** 表单提交失败事件 */
  SUBMIT_ERROR: 'submit-error',
  /** 更新可见性事件 */
  UPDATE_VISIBLE: 'update:visible',
  /** 保存禁用状态变更（用于父级按钮禁用控制） */
  SAVE_DISABLED_CHANGE: 'save-disabled-change'
}

/**
 * 销售预测表单混入
 * @description 提供销售预测表单的数据管理、验证规则和业务逻辑
 * @mixin
 */
export default {
  /**
   * 组件名称
   */
  name: 'ForecastFormMixin',

  /**
   * 组件属性定义
   * @description 定义组件接收的外部属性及其类型约束
   */
  props: {
    /**
     * 表单可见性控制
     * @description 控制表单的显示和隐藏
     */
    visible: {
      type: Boolean,
      default: false
    },

    /**
     * 编辑模式标识
     * @description 标识当前表单是否处于编辑模式
     */
    isEdit: {
      type: Boolean,
      default: false
    },

    /**
     * 初始表单数据
     * @description 用于表单初始化的数据对象
     */
    initialFormData: {
      type: Object,
      default: null
    },

    /**
     * 表单标题
     * @description 自定义表单标题，如果不提供则根据编辑模式自动生成
     */
    title: {
      type: String,
      default: ''
    },

    /**
     * 编辑时的表单数据
     */
    editData: {
      type: Object,
      default: () => ({})
    }
  },

  /**
   * 组件响应式数据
   * @description 定义组件的响应式数据状态
   * @this {ForecastFormMixinComponent & Vue}
   * @returns {ForecastFormMixinData} 组件数据对象
   */
  data() {
    return {
      /**
       * 销售预测表单数据模型
       * @description 存储销售预测表单的所有字段数据
       * @type {ForecastFormModel}
       */
      formData: {
        id: null,
        forecastCode: '',
        year: new Date().getFullYear().toString(),
        month: new Date().getMonth() + 1,
        customerId: null,
        customerCode: '',
        customerName: '',
        brandId: null,
        brandCode: '',
        brandName: '',
        itemId: null,
        itemCode: '',
        itemName: '',
        specs: '',
        itemSpecs: '',
        forecastQuantity: null,
        currentInventory: null,
        approvedName: '',
        approvedTime: null,
        approvalRemark: '',
        createTime: null,
        updateTime: null
      },

      /** 保存操作加载状态 */
      saveLoading: false,

      /** 表单加载状态 */
      formLoading: false,

      /** 客户选项列表
       * @type {Array<CustomerOption>}
       */
      customerOptions: [],

      /** 客户选项加载状态 */
      customerLoading: false,

      /** 物料选项列表
       * @type {Array<ItemOption>}
       */
      itemOptions: [],

      /** 物料选项加载状态 */
      itemLoading: false,

      /** 审批状态选项列表
       * @type {Array<ApprovalStatusOption>}
       */
      approvalStatusOptions: APPROVAL_STATUS_OPTIONS,

      /** 表单验证规则
       * @type {ForecastFormRules}
       */
      formRules: {
        ...FORECAST_FORM_RULES,
        year: [
          { required: true, message: '请选择年份', trigger: 'blur' }
        ]
      },

      /** 表单配置
       * @type {import('./types').FormOption}
       */
      formOption: {
        column: []
      },

      /** 品牌选项列表
       * @type {Array<SelectOption<number>>}
       */
      brandOptions: [],

      /** 物料表格数据（来自用户关联商品 pjpfStockDescList），带预测数量字段 */
      /** @type {Array<import('@/api/types/order').PjpfStockDesc & { forecastQuantity: number, brandCode?: string }>} */
      stockTableData: [],

      /** 表格加载状态 */
      tableLoading: false,

      /** 品牌描述列表（用于品牌信息匹配） */
      /** @type {Array<import('@/api/types/order').PjpfBrandDesc>} */
      brandDescList: [],

      /**
       * 用户关联库存物料列表（不直接展示在表格中）
       * @type {Array<import('@/api/types/order').PjpfStockDesc>}
       */
      stockDescList: [],

      /**
       * 物料选择下拉选项（通过 cname 搜索）
       * @type {Array<SelectOption<string>>}
       */
      stockSelectOptions: [],

      /**
       * 当前选择待导入的物料ID
       * @type {string | null}
       */
      selectedStockId: null,

      // 选择状态：存储已选中的行唯一键（跨分页）
      /** @type {Array<string|number>} */
      selectedRowKeys: [],

      // 程序化同步选择的守卫标记，避免回调环
      /** @type {boolean} */
      selectionSyncing: false,

      /** 当前库存 */
      currentInventory: null,

      // 分页状态
      /** 当前页（从1开始） */
      currentPage: 1,
      /** 每页条数（默认10） */
      pageSize: 10
    }
  },

  /**
   * 计算属性
   * @description 组件的响应式计算属性
   */
  computed: {
    /**
     * 表单标题
     * @description 根据编辑模式动态显示表单标题
     * @this {ForecastFormMixinComponent & Vue}
     * @returns {string} 表单标题文本
     */
    formTitle() {
      if (this.title) {
        return this.title
      }
      return this.isEdit ? '编辑销售预测' : '新增销售预测'
    },

    /**
     * 物料总数（用于分页 total）
     * @returns {number}
     */
    total() {
      return Array.isArray(this.stockTableData) ? this.stockTableData.length : 0
    },

    /**
     * 当前页数据（前端分页）
     * @returns {Array<import('@/api/types/order').PjpfStockDesc & { forecastQuantity: number, brandCode?: string, storeInventory?: string }>}
     */
    pagedStockTableData() {
      const list = Array.isArray(this.stockTableData) ? this.stockTableData : []
      const size = Number(this.pageSize) > 0 ? Number(this.pageSize) : 10
      const page = Number(this.currentPage) > 0 ? Number(this.currentPage) : 1
      const start = (page - 1) * size
      const end = start + size
      return list.slice(start, end)
    },

    // 是否有选中项（用于禁用批量删除按钮）
    /** @returns {boolean} */
    hasSelection() {
      return Array.isArray(this.selectedRowKeys) && this.selectedRowKeys.length > 0
    }
  },

  /**
   * 侦听器
   * @description 监听属性变化并执行相应操作
   */
  watch: {
    /**
     * 监听表单可见性变化
     * @this {ForecastFormMixinComponent & Vue}
     */
    visible: {
      /**
       * @this {ForecastFormMixinComponent & Vue}
       * @param {boolean} val - 新的可见性值
       */
      handler(/** @type {boolean} */ val) {
        if (val) {
          this.$nextTick(() => {
            // 表单显示时，初始化表单数据
            if (this.initialFormData) {
              this.formData = this.cleanAndFormatFormData(this.initialFormData)
            } else {
              // 使用 initFormData，确保新增模式默认填入“下个月”而不是当前月
              this.initFormData()
            }

            // 如果是编辑模式且有ID，则加载详情数据
            if (this.isEdit && this.formData.id) {
              this.loadForecastDetail(this.formData.id)
            }

            // 如果不是编辑模式，则生成预测编码
            if (!this.isEdit && !this.formData.forecastCode) {
            //   this.generateForecastCode()
            }

            // 新增模式下，自动获取并填充客户信息
            if (!this.isEdit) {
              this.loadCurrentCustomerInfo()
            }

            // 新增模式下进行年月预测存在性检查（默认年月）
            if (!this.isEdit) {
              this.checkForecastByMonthAndEmit && this.checkForecastByMonthAndEmit()
            }
          })
        } else {
          // 弹窗关闭：编辑态下清空选择，防止跨会话污染
          if (this.isEdit) {
            this.selectedRowKeys = []
            this.selectedStockId = null
            this.$nextTick(() => {
              this.syncTableSelection && this.syncTableSelection()
            })
          }
        }
      },
      immediate: true
    },

    /**
     * 监听初始表单数据变化
     * @param {ForecastFormModel} val - 新的初始表单数据
     * @this {ForecastFormMixinComponent & Vue}
     */
    initialFormData(/** @type {ForecastFormModel} */ val) {
      if (val) {
        this.formData = this.cleanAndFormatFormData(val)
      }
    },

    /**
     * 监听编辑数据变化
     * @this {ForecastFormMixinComponent & Vue}
     */
    editData: {
      /**
       * @this {ForecastFormMixinComponent & Vue}
       * @param {ForecastFormModel} newData
       */
      handler(/** @type {ForecastFormModel} */ newData) {
        if (newData && this.isEdit) {
          this.formData = {
            ...newData,
            year: newData.year ? newData.year.toString() : ''
          }
          // 回显子项明细到物料表格：将 pcBladeSalesForecastSummaryList -> stockTableData
          if (Array.isArray(newData.pcBladeSalesForecastSummaryList)) {
            try {
              this.stockTableData = newData.pcBladeSalesForecastSummaryList.map(item => ({
                // 尽量保持与 PjpfStockDesc 结构一致，便于表格渲染
                id: item.id ? safeBigInt(item.id) : undefined,
                goodsId: item.itemId ? safeBigInt(item.itemId) : undefined,
                code: item.itemCode || '',
                cname: item.itemName || '',
                brandId: item.brandId ? safeBigInt(item.brandId) : undefined,
                brandCode: item.brandCode || '',
                brandName: item.brandName || '',
                typeNo: item.specs || '',
                productDescription: item.pattern || '',
                brandItem: item.pattern || '',
                // 回显数据可能无库存，先不默认写入 '0'，留给后续合并方法填充
                storeInventory: undefined,
                // 预测数量用于编辑
                forecastQuantity: Number(item.forecastQuantity || 0)
              }))
              // 合并接口库存数据以支持回显
              this.mergeEchoStoreInventory && this.mergeEchoStoreInventory().catch(() => {})
            } catch (e) {
              console.warn('映射回显明细失败:', e)
            }
          }
        }
      },
      immediate: true,
      deep: true
    },

    /**
     * 监听编辑模式变化
     * @this {ForecastFormMixinComponent & Vue}
     */
    isEdit: {
      /**
       * @this {ForecastFormMixinComponent & Vue}
       * @param {boolean} newVal
       */
      handler(/** @type {boolean} */ newVal) {
        this.initFormOption()
        if (!newVal) {
          this.initFormData()
        }
        // 切换为编辑态时，通知父级恢复保存按钮可点击
        if (newVal && this.$emit) {
          this.$emit(FORECAST_FORM_EVENTS.SAVE_DISABLED_CHANGE, false)
        }
      },
      immediate: true
    },

    // 新增：监听年份与月份变更以触发按月校验（仅新增模式）
    'formData.year': {
      handler() {
        if (this.visible && !this.isEdit) {
          this.checkForecastByMonthAndEmit && this.checkForecastByMonthAndEmit()
        }
        // 年份变更重置分页到第一页
        this.currentPage = 1
      }
    },
    'formData.month': {
      handler() {
        if (this.visible && !this.isEdit) {
          this.checkForecastByMonthAndEmit && this.checkForecastByMonthAndEmit()
        }
        // 月份变更重置分页到第一页
        this.currentPage = 1
      }
    },

    /**
     * 监听预测ID变化
     * @param {string|number} val - 新的预测ID
     * @this {ForecastFormMixinComponent & Vue}
     */
    forecastId: {
      /**
       * @this {ForecastFormMixinComponent & Vue}
       * @param {string|number} val
       */
      handler(/** @type {string|number} */ val) {
        if (val && this.isEdit && this.visible) {
          this.loadForecastDetail(val)
        }
      },
      immediate: true
    }
  },

  /**
   * 组件创建时
   * @this {ForecastFormMixinComponent & Vue}
   */
  created() {
    this.initFormOption()
    this.initFormData()
  },

  /**
   * 组件方法
   * @description 组件的业务逻辑方法集合
   */
  methods: {
    /**
     * 创建初始表单数据
     * @description 创建销售预测表单的初始数据结构
     * @returns {ForecastFormModel} 初始化的表单数据对象
     * @this {ForecastFormMixinComponent & Vue}
     * @private
     */
    createInitialFormData() {
      /** @type {ForecastFormModel} */
      const initial = {
        id: null,
        forecastCode: '',
        year: new Date().getFullYear().toString(),
        month: new Date().getMonth() + 1,
        customerId: null,
        customerCode: '',
        customerName: '',
        brandId: null,
        brandCode: '',
        brandName: '',
        itemId: null,
        itemCode: '',
        itemName: '',
        specs: '',
        itemSpecs: '',
        forecastQuantity: null,
        currentInventory: null,
        approvedName: '',
        approvedTime: null,
        approvalRemark: '',
        createTime: null,
        updateTime: null
      }
      return initial
    },

    /**
     * 清理和格式化表单数据
     * @description 对表单数据进行清理和格式化处理
     * @param {Record<string, any>} data - 原始表单数据
     * @returns {ForecastFormModel} 清理和格式化后的表单数据
     * @this {ForecastFormMixinComponent & Vue}
     * @private
     */
    cleanAndFormatFormData(/** @type {Record<string, any>} */ data) {
      // 获取下个月的年份和月份作为默认值
      const now = new Date()
      const currentYear = now.getFullYear()
      const currentMonth = now.getMonth() + 1

      let defaultYear, defaultMonth
      if (currentMonth === 12) {
        // 当前是12月，下个月是明年1月
        defaultYear = currentYear + 1
        defaultMonth = 1
      } else {
        // 其他月份，直接 +1
        defaultYear = currentYear
        defaultMonth = currentMonth + 1
      }

      return {
        id: data.id || null,
        forecastCode: String(data.forecastCode || ''),
        year: data.year ? data.year.toString() : defaultYear.toString(),
        month: Number(data.month) || defaultMonth,
        customerId: data.customerId ? data.customerId.toString() : null,
        customerCode: String(data.customerCode || ''),
        customerName: String(data.customerName || ''),
        brandId: Number(data.brandId) || null,
        brandCode: String(data.brandCode || ''),
        brandName: String(data.brandName || ''),
        itemId: data.itemId ? data.itemId.toString() : null,
        itemCode: String(data.itemCode || ''),
        itemName: String(data.itemName || ''),
        specs: String(data.specs || ''),
        itemSpecs: String(data.itemSpecs || data.specs || ''),
        forecastQuantity: data.forecastQuantity !== undefined && data.forecastQuantity !== null && data.forecastQuantity !== '' ? Number(data.forecastQuantity) : null,
        currentInventory: Number(data.currentInventory) || null,
        approvalStatus: Number(data.approvalStatus) || APPROVAL_STATUS.PENDING,
        approvedName: String(data.approvedName || ''),
        approvedTime: data.approvedTime || null,
        approvalRemark: String(data.approvalRemark || ''),
        createTime: data.createTime || null,
        updateTime: data.updateTime || null
      }
    },

    /**
     * 加载销售预测详情
     * @description 根据ID加载销售预测详情数据
     * @param {string|number} id - 销售预测ID
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     * @private
     */
    async loadForecastDetail(/** @type {string|number} */ id) {
      if (!id) return

      try {
        this.formLoading = true
        const res = await getForecastDetail(id)

        if (res.data && res.data.success && res.data.data) {
          const detailData = res.data.data
          this.formData = this.cleanAndFormatFormData(detailData)

          // 加载客户选项数据，确保客户下拉框能正确显示
          if (this.formData.customerId) {
            await this.loadCustomerOption(this.formData.customerId, this.formData.customerName)
          }

          // 加载物料选项数据，确保物料下拉框能正确显示
          if (this.formData.itemId) {
            await this.loadItemOption(this.formData.itemId, this.formData.itemName, this.formData.itemCode, this.formData.specs)
          }

          // 映射明细到表格：pcBladeSalesForecastSummaryList -> stockTableData
          if (Array.isArray(detailData.pcBladeSalesForecastSummaryList)) {
            try {
              this.stockTableData = detailData.pcBladeSalesForecastSummaryList.map(item => ({
                id: item.id != null ? item.id : undefined,
                goodsId: item.itemId != null ? item.itemId : undefined,
                code: item.itemCode || '',
                cname: item.itemName || '',
                brandId: item.brandId != null ? item.brandId : undefined,
                brandCode: item.brandCode || '',
                brandName: item.brandName || '',
                typeNo: item.specs || '',
                productDescription: item.pattern || '',
                brandItem: item.pattern || '',
                // 回显数据可能无库存，先不默认写入 '0'，留给后续合并方法填充
                storeInventory: (item.storeInventory !== undefined && item.storeInventory !== null && item.storeInventory !== '') ? String(item.storeInventory) : undefined,
                forecastQuantity: Number(item.forecastQuantity || 0)
              }))
              // 合并接口库存数据以支持回显
              try {
                if (this.mergeEchoStoreInventory) {
                  await this.mergeEchoStoreInventory()
                }
              } catch (e) {
                console.warn('合并库存回显失败:', e)
              }
              // 合并完成后，规范化分页并回显选择（首屏强制回显）
              this.normalizePageAfterMutations()
            } catch (e) {
              console.warn('映射详情明细失败:', e)
            }
          }
        }
      } catch (error) {
        console.error('加载销售预测详情失败:', error)
      } finally {
        this.formLoading = false
      }
    },

    /**
     * 加载单个客户选项
     * @description 为编辑模式加载特定客户的选项数据
     * @param {string|number} customerId - 客户ID
     * @param {string} customerName - 客户名称
     * @param {string} [customerCode] - 客户编码（可选）
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     */
    async loadCustomerOption(/** @type {string|number} */ customerId, /** @type {string} */ customerName, /** @type {string} */ customerCode) {
      if (!customerId) return

      try {
        // customer-select组件会自动处理回显，我们只需要确保formData中有正确的值
        // 组件的watch会监听value变化并调用loadCustomerById方法

      } catch (error) {
        console.error('加载客户选项失败:', error)
      }
    },

    /**
     * 远程搜索客户
     * @description 根据关键字远程搜索客户数据
     * @param {string} query - 搜索关键字
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     */
    async remoteSearchCustomer(/** @type {string} */ query) {
      if (query === '') {
        this.customerOptions = []
        return
      }

      try {
        this.customerLoading = true
        const response = await getCustomerList(1, 20, {
        customerName: query
      })

        if (response.data && response.data.success && response.data.data) {
          const { records } = response.data.data
          this.customerOptions = records.map(item => ({
            value: item.Customer_ID,
            label: item.Customer_NAME,
            customerCode: item.Customer_CODE
          }))
        }
      } catch (error) {
        console.error('搜索客户失败:', error)
      } finally {
        this.customerLoading = false
      }
    },

    /**
     * 加载当前登录客户信息并填充表单
     * @this {ForecastFormMixinComponent & Vue}
     * @returns {Promise<void>}
     */
    async loadCurrentCustomerInfo() {
      try {
        const response = await getCustomerInfo()
        const ok = response && response.data && response.data.success
        const data = ok ? response.data.data : null
        if (ok && data) {
          // 根据接口common.d.ts中的CustomerInfoData结构进行赋值
          this.formData.customerId = data.Customer_ID ? Number(data.Customer_ID) : null
          this.formData.customerCode = data.Customer_CODE || ''
          this.formData.customerName = data.Customer_NAME || ''
        }
      } catch (e) {
        console.error('获取客户信息失败:', e)
      } finally {
        // 新增模式下，无论客户信息是否获取成功，都应确保物料明细加载一次。
        // 使用表格是否为空作为幂等保护，避免重复加载。
        if (!this.isEdit && Array.isArray(this.stockTableData) && this.stockTableData.length === 0) {
          try {
            await this.loadUserLinkGoods()
          } catch (err) {
            // loadUserLinkGoods 内部已做错误提示，这里静默即可
          }
        }
      }
    },

    /**
     * 加载单个物料选项（用于编辑时显示）
     * @param {string|number} itemId - 物料ID
     * @param {string} itemName - 物料名称
     * @param {string} itemCode - 物料编码
     * @param {string} specs - 物料规格
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    loadItemOption(/** @type {string|number} */ itemId, /** @type {string} */ itemName, /** @type {string} */ itemCode, /** @type {string} */ specs) {
      if (itemId && itemName && itemCode) {
        const option = {
          label: `${itemName} (${itemCode})`,
          value: itemId,
          itemName,
          itemCode,
          specs: specs || ''
        }

        // 检查是否已存在，避免重复添加
        const exists = this.itemOptions.some(opt => opt.value === itemId)
        if (!exists) {
          this.itemOptions.push(option)
        }
      }
    },

    /**
     * 远程搜索物料
     * @description 根据关键字远程搜索物料数据
     * @param {string} query - 搜索关键字
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     */
    async remoteSearchItem(/** @type {string} */ query) {
      if (query === '') {
        this.itemOptions = []
        return
      }

      try {
        this.itemLoading = true
        const res = await getItemList(1, 10, {
          itemName: query
        })

        if (res.data && res.data.success && res.data.data) {
          const { records } = res.data.data
          this.itemOptions = records.map(item => ({
            value: item.id,
            label: `${item.Item_Name} (${item.Item_Code})`,
            itemName: item.Item_Name,
            itemCode: item.Item_Code,
            specs: item.Item_PECS || '',
            id: item.id
          }))
        }
      } catch (error) {
        console.error('搜索物料失败:', error)
      } finally {
        this.itemLoading = false
      }
    },

    /**
     * 客户选择变化处理
     * @description 处理客户选择变化，更新表单中的客户相关字段
     * @param {string|number} customerId - 客户ID
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleCustomerChange(/** @type {string|number} */ customerId) {
      const customer = this.customerOptions.find(item => item.value === customerId)
      if (customer) {
        this.formData.customerId = typeof customer.value === 'string' ? parseInt(customer.value) || null : customer.value
        this.formData.customerCode = customer.customerCode
        this.formData.customerName = customer.label

        // 触发客户变更事件
        this.$emit(FORECAST_FORM_EVENTS.CUSTOMER_CHANGE, customer)
      }
    },

    /**
     * 物料选择变化处理
     * @description 处理物料选择变化，更新表单中的物料相关字段
     * @param {string|number} itemId - 物料ID
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleItemChange(/** @type {string|number} */ itemId) {
      const item = this.itemOptions.find(option => option.value === itemId)
      if (item) {
        this.formData.itemId = typeof item.value === 'string' ? parseInt(item.value) || null : item.value
        this.formData.itemCode = item.itemCode
        this.formData.itemName = item.itemName
        this.formData.specs = item.specs

        // 触发物料变更事件
        this.$emit(FORECAST_FORM_EVENTS.ITEM_CHANGE, item)
      }
    },

    /**
     * 初始化表单配置
     * @description 根据编辑模式初始化表单配置选项
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    initFormOption() {
      this.formOption = getFormOption(this.isEdit)
    },

    /**
     * 初始化表单数据
     * @description 根据编辑模式初始化表单数据，新增模式自动填入下个月
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    initFormData() {
      if (this.isEdit && this.editData) {
        // 编辑模式：使用传入的数据，确保year字段为字符串格式
        this.formData = {
          ...this.editData,
          year: this.editData.year ? this.editData.year.toString() : ''
        }
        // 若编辑入参未包含预测编码，则根据id加载详情以保证回显
        try {
          const id = (this.editData && (this.editData.id)) || (this.formData && (this.formData.id))
          if (!this.formData.forecastCode && id) {
            this.loadForecastDetail(id)
          }
        } catch (e) {
          // 非关键性异常，忽略
        }
      } else {
        // 新增模式：使用默认数据，自动填入下个月
        const now = new Date()
        const currentYear = now.getFullYear()
        const currentMonth = now.getMonth() + 1

        let nextYear, nextMonth
        if (currentMonth === 12) {
          // 当前是12月，下个月是明年1月
          nextYear = currentYear + 1
          nextMonth = 1
        } else {
          // 其他月份，直接 +1
          nextYear = currentYear
          nextMonth = currentMonth + 1
        }

        this.formData = {
          id: null,
          forecastCode: '',
          year: nextYear.toString(),
          month: nextMonth,
          customerId: null,
          customerCode: '',
          customerName: '',
          brandId: null,
          brandCode: '',
          brandName: '',
          itemId: null,
          itemCode: '',
          itemName: '',
          specs: '',
          itemSpecs: '',
          forecastQuantity: null,
          currentInventory: null,
          approvalStatus: APPROVAL_STATUS.PENDING,
          approvedName: '',
          approvedTime: null,
          approvalRemark: '',
          createTime: null,
          updateTime: null
        }

        // 生成预测编码
        // this.generateForecastCode()
      }
    },

    /**
     * 收集当前可见表单项的必填与数值规则错误信息（用于控制台打印）
     * @this {ForecastFormMixinComponent & Vue}
     * @returns {string[]} 错误消息列表
     */
    collectValidationErrors() {
      try {
        const errors = []
        const option = this.formOption || {}
        const groups = Array.isArray(option.group) ? option.group : []
        const isEmpty = (v) => v === undefined || v === null || v === ''

        groups.forEach(group => {
          const columns = Array.isArray(group.column) ? group.column : []
          columns.forEach(field => {
            if (!field || !field.prop) return
            // 仅校验可见字段
            if (field.display === false) return
            const rules = Array.isArray(field.rules) ? field.rules : []
            const val = this.formData ? this.formData[field.prop] : undefined
            // 必填校验
            const requiredRule = rules.find(r => r && r.required)
            if (requiredRule && isEmpty(val)) {
              const label = field.label || field.prop
              const msg = requiredRule.message || `${label}为必填项`
              errors.push(`${label}: ${msg}`)
            }
            // 数值最小值校验
            const numberRule = rules.find(r => r && r.type === 'number' && (r.min !== undefined))
            if (numberRule && !isEmpty(val)) {
              const num = Number(val)
              if (!Number.isFinite(num) || num < numberRule.min) {
                const label = field.label || field.prop
                const msg = numberRule.message || `${label}必须不小于${numberRule.min}`
                errors.push(`${label}: ${msg}`)
              }
            }
          })
        })
        return errors
      } catch (e) {
        return []
      }
    },

    /**
     * 表单提交事件处理（Avue表单 @submit 入口）
     * @description 响应 avue-form 的提交事件，统一走 submitForm 逻辑
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleSubmit(form, done, loading) {
      try {
        // 先结束 Avue 内置的按钮loading，避免未调用 done 导致一直loading
        if (typeof done === 'function') done()

            console.log(this.formData)
        // 采用旧实现风格：通过 this.$refs.forecastForm.validate 回调进行校验
        if (this.$refs && this.$refs.forecastForm && typeof this.$refs.forecastForm.validate === 'function') {
          this.$refs.forecastForm.validate((valid) => {
            if (!valid) {
              // 编辑态下，收集并打印具体未通过原因
              if (this.isEdit && typeof console !== 'undefined') {
                const errors = this.collectValidationErrors ? this.collectValidationErrors() : []
                if (errors && errors.length) {
                  console.group && console.group('表单校验未通过')
                  errors.forEach(msg => console.error(msg))
                  console.groupEnd && console.groupEnd()
                }
              }
              // 校验失败时，如存在 loading 回调（部分版本提供），尝试恢复按钮状态
              if (typeof loading === 'function') loading()
              // 通知父组件校验失败，便于父侧重置保存按钮loading
              this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, { message: '表单校验未通过' })
              return
            }
            // 校验通过后执行提交
            this.submitForm()
              .catch((e) => {
                console.error('提交异常:', e)
                // 将错误交由父组件统一处理，避免重复toast
                this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, e)
              })
          })
        } else {
          // 无法获取到 validate 时，直接尝试提交
          this.submitForm()
            .catch((e) => {
              console.error('提交异常:', e)
              // 将错误交由父组件统一处理，避免重复toast
              this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, e)
            })
        }
      } catch (e) {
        console.error('提交异常:', e)
        // 将错误交由父组件统一处理，避免重复toast
        this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, e)
      }
    },

    /**
     * 提交表单数据（main-add：提交销售预测主表及子项明细）
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     */
    async submitForm() {
      try {
        // 基础校验（客户必选）
        if (!this.formData.customerId) {
          this.$message && this.$message.warning('请选择客户')
          // 通知父组件失败，重置保存按钮loading
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, { message: '未选择客户' })
          return
        }

        // 转换年份与月份
        const year = typeof this.formData.year === 'string' ? parseInt(this.formData.year, 10) : this.formData.year
        const month = Number(this.formData.month)

        // 安全的ID转换：优先使用 BigInt 校验范围，再决定以 number 还是 string 传输
        /** @param {unknown} val @returns {string|number|''} */
        const toIdOutput = (val) => {
          if (val == null || val === '') return ''
          try {
            const bi = BigInt(String(val))
            const absBi = bi >= 0n ? bi : -bi
            const maxSafe = BigInt(Number.MAX_SAFE_INTEGER)
            if (absBi <= maxSafe) {
              return Number(bi)
            }
            return String(bi)
          } catch (e) {
            return String(val)
          }
        }

        // 安全的数值转换（用于数量等非ID字段）：若不可安全表示整数，仍以字符串传输
        /** @param {unknown} val @returns {number|string} */
        const toSafeNumberOrString = (val) => {
          if (val == null || val === '') return 0
          if (typeof val === 'number') {
            return Number.isFinite(val) ? val : String(val)
          }
          const parsed = Number(val)
          return Number.isFinite(parsed) ? parsed : String(val)
        }

        // 组装子项明细，仅保留预测数量>0的行
        const items = this.stockTableData
          .filter(row => Number(row.forecastQuantity) > 0)
          .map(row => {
            const matchedBrand = this.brandDescList.find(b => b.cname === row.brandName)
            const rawBrandId = row.brandId != null && row.brandId !== '' ? row.brandId : (matchedBrand ? matchedBrand.id : '')
            const rawItemId = row.goodsId

            const brandId = toIdOutput(rawBrandId)
            const itemId = toIdOutput(rawItemId)

            const base = {
              brandId,
              brandCode: row.brandCode || '',
              brandName: row.brandName || (matchedBrand ? matchedBrand.cname : ''),
              itemId,
              itemCode: row.code || '',
              itemName: row.cname || '',
              specs: row.typeNo || '',
              pattern: row.productDescription || row.brandItem || '',
              forecastQuantity: toSafeNumberOrString(row.forecastQuantity),
              approvalStatus: Number(this.formData.approvalStatus ?? 0)
            }
            // 编辑模式下，如果明细有 id，带上给后端做区分
            if (this.isEdit && (row.id != null && row.id !== '')) {
              return { id: toIdOutput(row.id), ...base }
            }
            return base
          })

        // 新增模式下需要至少一条有效明细；编辑模式下仅提交主表四个字段，不校验明细条数
        if (!this.isEdit && !items.length) {
        //   this.$message && this.$message.warning('请至少填写一条有效的预测数量')
          // 通知父组件失败，便于父侧重置保存按钮loading
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, { message: '未填写有效的预测明细' })
          return
        }

        // 组装载荷
        const payloadBase = {
          year: year || new Date().getFullYear(),
          month: month || (new Date().getMonth() + 1),
          approvalStatus: Number(this.formData.approvalStatus ?? 0),
          pcBladeSalesForecastSummaryList: items
        }

        let res
        if (this.isEdit && this.formData.id) {
          // 更新：需要主表 id
          res = await updateSalesForecastMain({ id: toIdOutput(this.formData.id), ...payloadBase })
        } else {
          // 新增
          res = await addSalesForecastMain(payloadBase)
        }

        if (res && res.data && res.data.success) {
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT, res.data)
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_SUCCESS, res.data)
        } else {
          const msg = (res && res.data && (res.data.msg || res.data.message)) || '提交失败'
          if (typeof this.setYearMonthDisabled === 'function') {
            this.setYearMonthDisabled(false)
          } else if (this.$refs) {
            this.$nextTick(() => {
              try {
                if (this.$refs.yearPicker) this.$refs.yearPicker.disabled = false
                if (this.$refs.monthSelect) this.$refs.monthSelect.disabled = false
              } catch (e) { /* 忽略 */ }
            })
          }
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, { message: msg, response: res })
        }
      } catch (error) {
        console.error('提交表单失败:', error)
        this.$emit && this.$emit(FORECAST_FORM_EVENTS.SUBMIT_ERROR, error)
      }
    },

    /**
     * 客户选择事件处理
     * @description 处理CustomerSelect组件的客户选择事件
     * @param {CustomerSelectData} customerData - 客户选择数据
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleCustomerSelected(/** @type {import('./types').CustomerSelectData} */ customerData) {
      if (customerData && customerData.customerId) {
        this.formData.customerId = Number(customerData.customerId)
        this.formData.customerCode = customerData.customerCode
        this.formData.customerName = customerData.customerName
        // 选中客户后加载该用户关联的品牌与库存物料（仅新增模式自动加载，编辑模式不覆盖回显数据）
        if (!this.isEdit) {
          this.loadUserLinkGoods()
        }
      } else {
        this.formData.customerId = null
        this.formData.customerCode = ''
        this.formData.customerName = ''
        // 清空表格
        this.stockTableData = []
      }
    },

    /**
     * 加载用户关联商品（品牌与库存）
     * @returns {Promise<void>}
     * @this {ForecastFormMixinComponent & Vue}
     */
    async loadUserLinkGoods() {
      try {
        this.tableLoading = true
        // 初始化容器
        this.stockTableData = []
        this.brandDescList = []
        this.stockDescList = []
        this.stockSelectOptions = []
        this.selectedStockId = null
        // 重置选择状态
        this.selectedRowKeys = []
        const res = await getUserLinkGoods()
        const payload = res && res.data && res.data.data ? res.data.data : null
        const brandList = (payload && payload.pjpfBrandDescList) || []
        const stockList = (payload && payload.pjpfStockDescList) || []
        this.brandDescList = brandList
        // 存储库存列表供选择用，不直接展示到表格
        this.stockDescList = stockList
        // 默认显示全部物料至下方表格，预测数量默认 1，用户可手动删除不需要的物料
        this.stockTableData = stockList.map(item => ({ ...item, forecastQuantity: 1 }))
        // 根据表格中已有的物料，过滤下拉选项
        this.updateStockSelectOptions()
        // 规范化分页并回显选择（新增模式首次加载）
        this.normalizePageAfterMutations()
      } catch (e) {
        console.error('加载用户关联商品失败:', e)
        this.$message.error(e.message || '加载用户关联商品失败')
      } finally {
        this.tableLoading = false
      }
    },

    /**
     * 导入所选物料到下方表格
     * @description 仅在点击"导入物料"按钮后，将选择的物料行添加到表格，默认预测数量为 0
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleImportSelectedStock() {
      // 未选择则提示
      if (!this.selectedStockId) {
        this.$message.warning('请先在上方选择要导入的物料')
        return
      }
      // 查找明细
      const stock = this.stockDescList.find(s => String(s.id) === this.selectedStockId)
      if (!stock) {
        this.$message.error('未找到所选物料数据，请重新选择')
        return
      }

      // 防止重复导入 - 使用多个字段进行更全面的重复检查
      const exists = this.stockTableData.some(row => {
        // 优先使用 id 进行匹配
        if (row.id !== undefined && row.id !== null && stock.id !== undefined && stock.id !== null && String(row.id) === String(stock.id)) {
          return true
        }
        // 使用 goodsId 进行匹配
        if (row.goodsId !== undefined && row.goodsId !== null && stock.goodsId !== undefined && stock.goodsId !== null && String(row.goodsId) === String(stock.goodsId)) {
          return true
        }
        // 使用 code 进行匹配
        if (row.code && stock.code && String(row.code) === String(stock.code)) {
          return true
        }
        return false
      })

      if (exists) {
        this.$message.warning('该物料已在列表中')
        this.selectedStockId = null
        return
      }

      // 添加到表格，默认预测数量为 1
      this.stockTableData.push({ ...stock, forecastQuantity: 1 })
      // 清空已选
      this.selectedStockId = null
      // 导入后更新下拉选项（过滤掉已在表格中的物料）
      this.updateStockSelectOptions()

      // 导入后保持当前页不变；规范化分页以应对边界，并同步选择回显
      this.normalizePageAfterMutations()
    },

    /**
     * 删除物料行（分页适配）
     * @param {import('./types').ForecastFormMixinData['stockTableData'][number]} row
     * @param {number} index - 当前页内索引
     * @returns {Promise<void>}
     */
    async handleDelete(row, index) {
      try {
        // 先通过唯一键定位（优先 id，其次 goodsId）
        const keyId = row && (row.id != null ? row.id : row.goodsId)
        let removeIndex = -1
        if (keyId != null) {
          removeIndex = this.stockTableData.findIndex(r => (r.id != null ? r.id : r.goodsId) === keyId)
        }
        // 如果无唯一键或未找到，则按分页换算全局索引
        if (removeIndex < 0 && typeof index === 'number') {
          const globalIndex = (Math.max(1, Number(this.currentPage)) - 1) * Math.max(1, Number(this.pageSize)) + index
          if (globalIndex >= 0 && globalIndex < this.stockTableData.length) {
            removeIndex = globalIndex
          }
        }
        if (removeIndex < 0) {
          this.$message && this.$message.warning('未定位到要删除的记录')
          return
        }

        await this.$confirm('确认删除该物料吗？删除后可重新通过上方选择器导入。', '提示', {
          type: 'warning',
          confirmButtonText: '删除',
          cancelButtonText: '取消'
        })

        // 记录待删除行的唯一键，用于同步选择状态
        const removedKey = this.getRowUniqueKey(row)

        this.$delete(this.stockTableData, removeIndex)

        // 同步移除选择状态中的该行
        if (removedKey != null) {
          this.selectedRowKeys = (Array.isArray(this.selectedRowKeys) ? this.selectedRowKeys : []).filter(k => k !== removedKey)
        }

        // 删除后校正页码：若当前页无数据则回退到上一页
        this.normalizePageAfterMutations()

        // 删除后更新下拉选项（被删除的物料重新回到可选择项）
        this.updateStockSelectOptions()

        // [A] removed toast: deletion success message suppressed by requirement
      } catch (e) {
        // 用户取消不提示为错误，其他情况做日志记录
        if (e && e !== 'cancel') {
          console.error('删除失败：', e)
          this.$message && this.$message.error('删除失败，请稍后重试')
        }
      }
    },

    /**
     * 表格选择变更（el-table @selection-change）
     * @param {Array<import('./types').ForecastFormMixinData['stockTableData'][number]>} selection
     * @returns {void}
     */
    handleSelectionChange(selection) {
      // 程序化同步时不触发合并逻辑，避免回调环
      if (this.selectionSyncing) return
      // 基于当前页数据与新选择集，维护跨页 selection 的“并集 - 当前页未选差集”
      const currentPageRows = Array.isArray(this.pagedStockTableData) ? this.pagedStockTableData : []
      const currentPageKeys = new Set(
        currentPageRows
          .map(r => this.getRowUniqueKey(r))
          .filter(k => k !== undefined && k !== null && k !== '')
      )

      const nextSelectedOnPage = new Set(
        Array.isArray(selection)
          ? selection
              .map(r => this.getRowUniqueKey(r))
              .filter(k => k !== undefined && k !== null && k !== '')
          : []
      )

      const prev = Array.isArray(this.selectedRowKeys) ? this.selectedRowKeys : []
      const union = new Set(prev)

      // 1) 移除当前页中被取消勾选的键
      currentPageKeys.forEach(k => {
        if (!nextSelectedOnPage.has(k)) {
          union.delete(k)
        }
      })
      // 2) 加入当前页新勾选的键
      nextSelectedOnPage.forEach(k => {
        union.add(k)
      })

      this.selectedRowKeys = Array.from(union)
    },

    /**
     * 行唯一键生成函数（绑定给 :row-key）
     * 更健壮的容错：依次尝试 id -> goodsId -> itemId -> code -> itemCode -> 组合键(cname/itemName + code/itemCode + brandCode + typeNo/specs)
     * @param {import('./types').ForecastFormMixinData['stockTableData'][number]} row
     * @returns {string | number}
     */
    getRowUniqueKey(row) {
      if (!row || typeof row !== 'object') return ''
      /** @type {any} */
      const anyRow = /** @type {any} */ (row)
      // 简化：仅按 id -> goodsId -> code 顺序
      if (anyRow.id !== undefined && anyRow.id !== null) return /** @type {any} */ (anyRow.id)
      if (anyRow.goodsId !== undefined && anyRow.goodsId !== null) return /** @type {any} */ (anyRow.goodsId)
      if (anyRow.code) return String(anyRow.code)
      return ''
    },

    /**
     * 更新物料下拉选项（过滤已在表格中的物料）
     * @returns {void}
     */
    updateStockSelectOptions() {
      try {
        const table = Array.isArray(this.stockTableData) ? this.stockTableData : []
        const source = Array.isArray(this.stockDescList) ? this.stockDescList : []

        const idSet = new Set(table.filter(r => r && r.id !== undefined && r.id !== null).map(r => String(r.id)))
        const goodsIdSet = new Set(table.filter(r => r && r.goodsId !== undefined && r.goodsId !== null).map(r => String(r.goodsId)))
        const codeSet = new Set(table.filter(r => r && r.code).map(r => String(r.code)))

        const options = source
          .filter(item => {
            const byId = item && item.id !== undefined && item.id !== null && idSet.has(String(item.id))
            const byGoods = item && item.goodsId !== undefined && item.goodsId !== null && goodsIdSet.has(String(item.goodsId))
            const byCode = item && item.code && codeSet.has(String(item.code))
            return !(byId || byGoods || byCode)
          })
          .map(item => ({
            label: /** @type {any} */ (item.cname || item.code || ''),
            value: /** @type {any} */ (String(item.id))
          }))

        this.stockSelectOptions = options
        // 如果当前选中不在可选项中，则清空
        const hasSelected = options.some(opt => opt && opt.value === this.selectedStockId)
        if (!hasSelected) {
          this.selectedStockId = null
        }
      } catch (e) {
        console.warn('更新物料下拉选项失败:', e)
      }
    },

    /**
     * 批量删除已选中的物料
     * @returns {Promise<void>}
     */
    async handleBatchDelete() {
      try {
        const keys = new Set(Array.isArray(this.selectedRowKeys) ? this.selectedRowKeys : [])
        if (keys.size === 0) {
          this.$message && this.$message.warning('请先在下方表格选择要删除的物料')
          return
        }

        await this.$confirm('确认删除已选中的物料吗？删除后可重新通过上方选择器导入。', '提示', {
          type: 'warning',
          confirmButtonText: '删除',
          cancelButtonText: '取消'
        })

        const filtered = (Array.isArray(this.stockTableData) ? this.stockTableData : []).filter(row => {
          const key = this.getRowUniqueKey(row)
          return !keys.has(key)
        })
        this.stockTableData = filtered

        // 清空选择并校正页码
        this.selectedRowKeys = []
        this.normalizePageAfterMutations()
        // 刷新下拉选项
        this.updateStockSelectOptions()

        // [A] removed toast: batch deletion success message suppressed by requirement
      } catch (e) {
        if (e && e !== 'cancel') {
          console.error('批量删除失败：', e)
          this.$message && this.$message.error('批量删除失败，请稍后重试')
        }
      }
    },

    /**
     * 页容量变更（el-pagination: size-change）
     * @param {number} size
     * @returns {void}
     */
    handleSizeChange(size) {
      const newSize = Number(size) > 0 ? Number(size) : 10
      this.pageSize = newSize
      // 变更每页大小后，将页码重置为 1
      this.currentPage = 1
      // 同步当前页表格的选择回显
      this.syncTableSelection()
    },

    /**
     * 页码变更（el-pagination: current-change）
     * @param {number} page
     * @returns {void}
     */
    handlePageChange(page) {
      const newPage = Number(page) > 0 ? Number(page) : 1
      this.currentPage = newPage
      // 同步当前页表格的选择回显
      this.syncTableSelection()
    },

    /**
     * 变更后校正页码（删除/导入后调用）
     * @returns {void}
     */
    normalizePageAfterMutations() {
      const total = this.total
      const size = Math.max(1, Number(this.pageSize) || 10)
      const maxPage = Math.max(1, Math.ceil(total / size))
      if (this.currentPage > maxPage) {
        this.currentPage = maxPage
      }
      if (this.currentPage < 1) {
        this.currentPage = 1
      }
      // 校正页码后，确保当前页的表格勾选状态与 selectedRowKeys 保持一致
      this.syncTableSelection()
    },

    /**
     * 品牌变更处理
     * @param {number} brandId - 品牌ID
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleBrandChange(/** @type {number} */ brandId) {
      const selectedBrand = this.brandOptions.find(brand => /** @type {any} */ (brand).id === brandId)
      if (selectedBrand) {
        this.formData.brandId = brandId
        this.formData.brandCode = /** @type {any} */ (selectedBrand).code
        this.formData.brandName = /** @type {any} */ (selectedBrand).name
      } else {
        this.formData.brandId = null
        this.formData.brandCode = ''
        this.formData.brandName = ''
      }
      // 品牌切换后清空选中行，刷新下拉选项并同步表格选择
      this.selectedRowKeys = []
      this.$nextTick(() => {
        this.syncTableSelection && this.syncTableSelection()
      })
      this.updateStockSelectOptions && this.updateStockSelectOptions()
    },

    /**
     * 物料选择处理
     * @description 处理MaterialSelect组件的物料选择事件
     * @param {MaterialSelectData} materialData - 物料选择数据
     * @returns {void}
     * @this {ForecastFormMixinComponent & Vue}
     */
    handleMaterialSelected(/** @type {import('./types').MaterialSelectData} */ materialData) {
      if (materialData && materialData.itemId) {
        this.formData.itemId = Number(materialData.itemId)
        this.formData.itemCode = materialData.itemCode
        this.formData.itemName = materialData.itemName
        this.formData.itemSpecs = materialData.specification || ''
        // 获取当前库存
        this.getCurrentInventory(materialData.itemId)
      } else {
        this.formData.itemId = null
        this.formData.itemCode = ''
        this.formData.itemName = ''
        this.formData.itemSpecs = ''
        this.currentInventory = null
      }
    },

    /**
     * 合并回显行的库存数量
     * @this {ForecastFormMixinComponent & Vue}
     * @description 使用 getUserLinkGoods 接口返回的库存数据，为编辑态回显的物料行补齐 storeInventory 字段
     * @returns {Promise<void>}
     */
    async mergeEchoStoreInventory() {
      try {
        if (!Array.isArray(this.stockTableData) || this.stockTableData.length === 0) return
        const res = await getUserLinkGoods()
        const payload = res && res.data && res.data.data ? res.data.data : null
        const stockList = (payload && payload.pjpfStockDescList) || []
        if (!Array.isArray(stockList) || stockList.length === 0) return

        // 在编辑模式下，确保"导入物料"的选择器有数据可选
        // 不修改现有表格数据，仅补齐选择来源
        this.stockDescList = stockList
        this.stockSelectOptions = stockList.map(item => ({
          label: item.cname,
          value: item.id
        }))

        // 构建基于 goodsId 与 code 的索引映射
        /** @type {Map<string, string|undefined>} */
        const invByGoodsId = new Map()
        /** @type {Map<string, string|undefined>} */
        const invByCode = new Map()
        stockList.forEach(s => {
          const inv = (s && s.storeInventory !== undefined && s.storeInventory !== null && s.storeInventory !== '') ? String(s.storeInventory) : undefined
          if (s && s.goodsId !== undefined && s.goodsId !== null) invByGoodsId.set(String(s.goodsId), inv)
          if (s && s.code) invByCode.set(String(s.code), inv)
        })

        // 合并库存到现有表格数据（仅填充缺失的库存字段）
        this.stockTableData = this.stockTableData.map(row => {
          const hasInv = !(row.storeInventory === undefined || row.storeInventory === null || row.storeInventory === '')
          if (hasInv) return row
          const keyGoodsId = row && row.goodsId !== undefined && row.goodsId !== null ? String(row.goodsId) : ''
          const keyCode = row && row.code ? String(row.code) : ''
          const fromGoods = keyGoodsId ? invByGoodsId.get(keyGoodsId) : undefined
          const fromCode = (!fromGoods && keyCode) ? invByCode.get(keyCode) : undefined
          const value = (fromGoods !== undefined && fromGoods !== null && fromGoods !== '') ? fromGoods : ((fromCode !== undefined && fromCode !== null && fromCode !== '') ? fromCode : '0')
          return { ...row, storeInventory: String(value) }
        })
      } catch (e) {
        console.warn('回显库存合并失败:', e)
      }
    },

    /**
     * 新增模式：检查指定年月是否已有预测，并通过事件通知父组件控制保存按钮禁用
     * @returns {Promise<void>}
     */
    async checkForecastByMonthAndEmit() {
      try {
        const year = typeof this.formData.year === 'string' ? parseInt(this.formData.year, 10) : Number(this.formData.year)
        const month = Number(this.formData.month)
        if (!year || !month) return
        // 仅新增模式需要校验
        if (this.isEdit) {
          this.$emit && this.$emit(FORECAST_FORM_EVENTS.SAVE_DISABLED_CHANGE, false)
          return
        }
        const res = await getSalesForecastSummaryByMonth(year, month)
        const hasData = !!(res && res.data && res.data.success && Array.isArray(res.data.data) && res.data.data.length > 0)
        this.$emit && this.$emit(FORECAST_FORM_EVENTS.SAVE_DISABLED_CHANGE, hasData)
      } catch (e) {
        // 异常时不阻塞新增，默认允许保存
        this.$emit && this.$emit(FORECAST_FORM_EVENTS.SAVE_DISABLED_CHANGE, false)
      }
    },

    /**
     * 程序化同步当前页表格勾选状态到 selectedRowKeys
     * @returns {void}
     */
    syncTableSelection() {
      try {
        /** @type {any} */
        const table = this.$refs && this.$refs.stockTable
        if (!table || typeof table.clearSelection !== 'function' || typeof table.toggleRowSelection !== 'function') return
        this.selectionSyncing = true
        this.$nextTick(() => {
          try {
            table.clearSelection()
            const selectedSet = new Set(Array.isArray(this.selectedRowKeys) ? this.selectedRowKeys : [])
            const rows = Array.isArray(this.pagedStockTableData) ? this.pagedStockTableData : []
            rows.forEach(row => {
              const key = this.getRowUniqueKey(row)
              if (selectedSet.has(key)) {
                table.toggleRowSelection(row, true)
              }
            })
          } catch (e) {
            console.warn('同步表格选择异常:', e)
          } finally {
            this.selectionSyncing = false
          }
        })
      } catch (e) {
        console.warn('syncTableSelection 初始化失败:', e)
        this.selectionSyncing = false
      }
    },
  }
}