<template>
  <!-- 模板部分保持不变 -->
  <div>
    <el-card>
      <div>
        <span class="show-text">订单号:</span>
        <el-input v-model="orderNo" placeholder="请输入订单号" clearable style="width: 100px; margin-right: 10px" />
        <!-- <span class="show-text">合同号:</span>
        <el-input v-model="contractNo" placeholder="请输入合同号" clearable style="width: 130px; margin-right: 10px" /> -->
        <span class="show-text">零件编码:</span>
        <el-input v-model="productCode" placeholder="请输入零件编码" clearable style="width: 150px; margin-right: 10px" />
        <span class="show-text">零件名称:</span>
        <el-input v-model="productName" placeholder="请输入零件名称" clearable style="width: 100px; margin-right: 10px" />
        <!-- <span class="show-text">质检类型:</span>
        <el-select
          v-model="QualityStatus"
          clearable
          placeholder="请选择质检类型"
          style="width: 150px; margin-right: 10px"
        >
          <el-option label="全部" value="10" />
          <el-option label="收检" value="0" />
          <el-option label="终检" value="1" />
          <el-option label="来料检验" value="2" />
          <el-option label="退库检验" value="3" />
        </el-select> -->
        <span class="show-text">供应商:</span>
        <el-input v-model="supplierName" placeholder="请输入供应商" clearable style="width: 150px; margin-right: 10px" />
        
        <span class="show-text">状态筛选:</span>
        <el-select v-model="statusFilter" clearable placeholder="请选择" style="width: 150px; margin-right: 10px">
          <el-option label="全部" :value="false" />
          <el-option label="收料小于发料" :value="true" />
        </el-select>
        <el-button :disabled="!!loading" icon="el-icon-search" plain type="primary" @click="searchTable()">查询</el-button>
        <el-button style="width: 100px;" icon="el-icon-download" type="primary"  @click="exportExcel">Excel导出</el-button>
      </div>
      
      <el-tabs v-model="activeTab" type="card" class="custom-tabs">
        <el-table 
          v-loading="loading" 
          :data="mergedTableData" 
          :height="'67vh'" 
          border
          element-loading-background="rgba(0, 0, 0, 0.2)" 
          element-loading-spinner="el-icon-loading"
          highlight-current-row 
          size="mini" 
          style="width: 100%;margin-top: 20px;" 
          tooltip-effect="dark"
          :row-class-name="tableRowClassName"  
          @row-click="handleRowClick">
          
          <el-table-column type="selection" width="55" align="center" />
          <el-table-column align="center" prop="供应商名称" label="供应商" width="200"  />
          <el-table-column align="center" prop="订单号" label="订单号" width="80" />
          <el-table-column align="center" prop="计划号" label="计划号" width="80" />
          <el-table-column align="center" prop="合同号" label="合同号" width="100" />
          <el-table-column align="center" prop="产品编码" label="零件编码" width="220"/>
          <el-table-column align="center" prop="产品名称" label="零件名称" width="190" />
          <el-table-column align="center" prop="工序名称" label="工序名称" width="100" />
          <el-table-column align="center" prop="材质" label="材质" width="100" />
          <el-table-column align="center" prop="指派数量" label="数量" width="100" />
          <el-table-column align="center" prop="含税单价" label="单价" width="100" />
          <el-table-column align="center" prop="含税行总计" label="金额" width="100" />
          <el-table-column align="center" prop="开始时间" label="发料日期" width="160">
            <template slot-scope="scope">{{ scope.row.开始时间 == '1900-01-01 00:00:00'? '':scope.row.开始时间}}</template>
          </el-table-column>
          <el-table-column align="center" prop="计划完成时间" label="要求到货日期" width="160" />
          <el-table-column align="center" prop="" label="外协预计到货" width="160">
            <template slot-scope="scope">{{ scope.row.采购预计到货日期 == '1900-01-01 00:00:00'? '':scope.row.采购预计到货日期}}</template>
          </el-table-column>
          <el-table-column align="center" prop="外协结束时间" label="收货日期" width="160" >
            <template slot-scope="scope">{{ scope.row.外协结束时间 == '1900-01-01 00:00:00'? '':scope.row.外协结束时间}}</template>
          </el-table-column>
          <el-table-column align="center" prop="收料数量" label="收货数量" width="120" />
          <el-table-column align="center" prop="收检合格数" label="合格数量" width="100" />
          <el-table-column align="center" prop="收检不合格数" label="报废数量" width="100" />
          <el-table-column align="center" prop="开票数量" label="开票状态" width="100" >
            <template slot-scope="scope">{{ scope.row.开票数量 >0? '是':'否'}}</template>
          </el-table-column>
          <el-table-column align="center" prop="发料数量合计" label="发料数量" width="100" />
          <el-table-column align="center" prop="收料数量_报工" label="收料数量" width="100" />
        </el-table>
        
        <div class="block" style="margin-top: 10px;">
          <el-pagination
            :current-page="pageCurrent"
            :page-sizes="[100, 200, 500]"
            :page-size="pageSize"
            :total="total1"
            layout="total, sizes, prev, pager, next, jumper"
            @size-change="handleSizeChanges"
            @current-change="handleCurrentChanges" />
        </div>
      </el-tabs>
    </el-card>
  </div>
</template>

<script>
export default {
  data() {
    return {
      // 分页
      pageCurrent: 1,
      pageSize: 100,
      total1: 0,
      
      // 搜索条件
      QualityStatus:'10',
      startDate:null,
      endDate:null,
      orderNo:'',
      contractNo:'',
      productCode:'',
      productName:'',

      
      // 表格数据
      loading: false,
      activeTab: 'first',
      tableData: [],

      // 新增相关数据
      orderList: [],
      exporting: false,
      // processList: [],
      // personnelList: [],
      mergedTableData: [], // 合并后的数据
      mergedDataMap: new Map(), // 用于存储合并数据对应的原始数据组
      supplierName:'',
      statusFilter:''
    }
  },
  
  mounted() {
    // this.searchTable()
  },
  
  methods: {
    // ============ 表格相关方法 ============
    tableRowClassName({ row, rowIndex }) {
      if (!row.结束时间 || row.结束时间 === '') {
        return 'row-without-endtime'
      }
      return ''
    },
    
    handleRowClick(row) {
      this.currentTask = row
    },
    
    handleSelectionChange(val) {
      this.multipleSelection = val
    },
    exportExcel() {
      // 校验日期是否已选择
      // if (!this.startDate || !this.endDate) {
      //   this.$message.warning('请选择开始日期和结束日期')
      //   return
      // }
      // // 校验开始日期不能大于结束日期
      // if (this.startDate > this.endDate) {
      //   this.$message.warning('开始日期不能大于结束日期')
      //   return
      // }
      const param = []
      param.push(["订单号", this.orderNo ]);
      param.push(["产品编码", this.productCode ]);
      param.push(["产品名称", this.productName ]);
      param.push(["供应商", this.supplierName]);      // 新增供应商筛选
      param.push(["状态过滤", this.statusFilter ? 1 : 0]);  // 新增状态筛选
      
      this.exporting = true
      const Data = this.CreateData('2001', '生产管理_外协报表_导出', param)
      this.exportExcel_NPOI(Data).finally(() => {
        this.exporting = false
      })
    },
    // ============ 数据加载方法 ============
    // loadPersonnelList() {
    //   var param = []
    //   var Data = this.CreateData('11', '系统管理_人员管理_所有有效人员查询', param)
    //   this.ExecDatabase(Data).then(response => {
    //     if (response.data && response.data.length > 0) {
    //       this.personnelList = response.data.map(person => ({
    //         key: person.人员编号,
    //         label: person.人员姓名,
    //         disabled: false
    //       }))
    //     }
    //   })
    // },
    
    // loadOrderList(orderId) {
    //   var param = []
    //   param.push(['订单编号', orderId])
    //   var Data = this.CreateData('11', '工时校验_获取订单列表', param)
    //   this.ExecDatabase(Data).then(response => {
    //     this.orderList = response.data || []
    //   }).catch(error => {
    //     console.error('加载订单列表失败:', error)
    //     this.orderList = []
    //   })
    // },
    

    // loadProcessList(orderId) {
    //   var param = [['订单编号', orderId]]
    //   var Data = this.CreateData('11', '工时校验_获取订单工序', param)
    //   this.ExecDatabase(Data).then(response => {
    //     this.processList = response.data || []
    //   }).catch(error => {
    //     console.error('加载工序列表失败:', error)
    //     this.processList = []
    //   })
    // },
    

    
    // ============ 分页方法 ============
    handleSizeChanges(val) {
      this.pageCurrent = 1
      this.pageSize = val
      this.searchTable()
    },
    
    handleCurrentChanges(val) {
      this.pageCurrent = val
      this.searchTable()
    },
    
    // 修改 searchTable 方法
    searchTable() {
      this.loading = true
      
      var param = [
        ["订单号", this.orderNo],
        ["合同号", this.contractNo],
        ["产品编码", this.productCode],
        ["产品名称", this.productName],
        ["计划号", ''],
        ["供应商", this.supplierName],  // 新增供应商筛选
        ["状态过滤", this.statusFilter ? 1 : 0],  // 新增状态筛选
        ['PageCurrent', this.pageCurrent],
        ['pageSize', this.pageSize],
        ['PageCount', '1111', 'int', '1'],
        ['ItemCount', '1111', 'int', '1']
      ]
      
      var Data = this.CreateData('11', '生产管理_外协报表_查询', param)
      this.ExecDatabase(Data).then(response => {
        // 直接使用返回的数据，无需合并
        this.mergedTableData = response.data.result || []
        this.total1 = parseInt(response.data.output[0].ItemCount)
        this.loading = false
      }).catch(error => {
        this.$message.error('查询失败：' + error.message)
        this.loading = false
      })
    },

// 删除以下方法（不再需要）：
// mergeTableData()
// mergeGroup()
// shouldIncludeByExecutionStatus()
    mergeTableData() {
      if (!this.tableData || this.tableData.length === 0) {
        this.mergedTableData = [];
        this.mergedDataMap.clear();
        return;
      }
      const groupedByOrder = {};
      this.tableData.forEach(item => {
        // 使用订单号 + 拆分内码作为分组键
        const groupKey = `${item.订单号}_${item.拆分内码}`;
        
        if (!groupedByOrder[groupKey]) {
          groupedByOrder[groupKey] = [];
        }
        groupedByOrder[groupKey].push(item);
      });

      const mergedData = [];
      this.mergedDataMap.clear();

        // 处理每个订单组
        Object.keys(groupedByOrder).forEach(orderNo => {
          const orderItems = groupedByOrder[orderNo];
          
          // 按订单行号排序
          orderItems.sort((a, b) => a.订单行号 - b.订单行号);
          
          let currentGroup = [orderItems[0]];
          
          for (let i = 1; i < orderItems.length; i++) {
            const currentItem = orderItems[i];
            const lastItem = orderItems[i - 1];
            
            // 检查订单行号是否连续且外协分组相同
            if (currentItem.订单行号 === lastItem.订单行号 + 1 && currentItem.外协分组 === lastItem.外协分组 && currentItem.拆分内码 === lastItem.拆分内码) {
              currentGroup.push(currentItem);
            } else {
              // 不连续，处理当前组并开始新组
              const mergedItem = this.mergeGroup(currentGroup);
              // 应用执行状态筛选
              if (this.shouldIncludeByExecutionStatus(mergedItem)) {
                mergedData.push(mergedItem);
                // 存储合并数据对应的原始数据组
                this.mergedDataMap.set(mergedItem.uniqueKey, currentGroup);
              }
              currentGroup = [currentItem];
            }
          }
          
          // 处理最后一组
          if (currentGroup.length > 0) {
            const mergedItem = this.mergeGroup(currentGroup);
            // 应用执行状态筛选
            if (this.shouldIncludeByExecutionStatus(mergedItem)) {
              mergedData.push(mergedItem);
              // 存储合并数据对应的原始数据组
              this.mergedDataMap.set(mergedItem.uniqueKey, currentGroup);
            }
          }
        });

        this.mergedTableData = mergedData;
    },

    // 新增：根据执行状态筛选数据（纯前端筛选）
    shouldIncludeByExecutionStatus(mergedItem) {
      const 执行状态 = this.dostate; // 0=全部, 1=可执行, 2=不可执行
      
      if (执行状态 === 0) {
        return true; // 全部，不筛选
      }
      
      const itemExecutionStatus = mergedItem.执行状态 || 1; // 默认可执行
      
      if (执行状态 === 1) {
        return itemExecutionStatus === 1; // 只显示可执行
      } else if (执行状态 === 2) {
        return itemExecutionStatus === 2; // 只显示不可执行
      }
      
      return true;
    },
        // 合并单个组的数据
    mergeGroup(group) {
      if (group.length === 1) {
        const item = group[0];
        item.uniqueKey = `${item.订单号}_${item.订单行号}_${item.TaskAID}`;
        // 确保TaskAID是字符串类型
        item.TaskAID = String(item.TaskAID);
        
        // 计算单条记录的执行状态
        const 上序合格数 = item.上序合格数 || 0;
        const 订单行号 = item.订单行号;
        item.执行状态 = (订单行号 === 1 || 上序合格数 > 0) ? 1 : 2;
        
        return item;
      }
      
      // 找出订单行号最大的那条数据
      const maxOrderLineItem = group.reduce((max, current) => 
        (current.订单行号 > max.订单行号) ? current : max
      );
      
      // 以最大订单行号的数据为基础创建合并项
      const mergedItem = { ...maxOrderLineItem };
      
      // 生成唯一标识key（保留所有组的标识）
      mergedItem.uniqueKey = group.map(item => `${item.订单号}_${item.订单行号}_${item.TaskAID}`).join('|');
      
      // 拼接工序名称（逗号间隔）- 保留所有工序名称
      const processNames = group.map(item => item.工序名称);
      mergedItem.工序名称 = processNames.join(',');
      
      // 拼接TaskAID（逗号间隔）- 保留所有TaskAID
      const taskAIDs = [...new Set(group.map(item => String(item.TaskAID)))];
      mergedItem.TaskAID = taskAIDs.join(',');
      
      // 计划开始时间取最小值（保持不变）
      const startTimes = group.map(item => new Date(item.计划开始时间));
      mergedItem.计划开始时间 = new Date(Math.min(...startTimes)).toISOString().slice(0, 19).replace('T', ' ');
      
      // 计划完成时间取最大值（保持不变）
      const endTimes = group.map(item => new Date(item.计划完成时间));
      mergedItem.计划完成时间 = new Date(Math.max(...endTimes)).toISOString().slice(0, 19).replace('T', ' ');
      
      // 完成数量取最大值（保持不变）
      const wcnum = group.map(item => item.完成数量);
      mergedItem.完成数量 = Math.max(...wcnum);
      
      // 开始时间取最大值（保持不变）
      const starttime = group
          .map(item => new Date(item.开始时间))
          .filter(date => !isNaN(date.getTime()) && date >= new Date('1900-01-01'));
      
      if (starttime.length > 0) {
          mergedItem.开始时间 = new Date(Math.max(...starttime))
              .toISOString()
              .slice(0, 19)
              .replace('T', ' ');
      } else {
          mergedItem.开始时间 = null;
      }
      
      // 外协结束时间取最大值（注意：原代码有bug，使用的是starttime，已修正）
      const endtime = group
          .map(item => new Date(item.外协结束时间))
          .filter(date => !isNaN(date.getTime()) && date >= new Date('1900-01-01'));
      
      if (endtime.length > 0) {
          mergedItem.外协结束时间 = new Date(Math.max(...endtime))
              .toISOString()
              .slice(0, 19)
              .replace('T', ' ');
      } else {
          mergedItem.外协结束时间 = null;
      }
      
      // 外协打印次数取最大值（保持不变）
      const printnum = group.map(item => item.外协打印次数);
      mergedItem.外协打印次数 = Math.max(...printnum);
      
      // 收料数量取最大值（保持不变）
      const slnum = group.map(item => item.收料数量);
      mergedItem.收料数量 = Math.max(...slnum);
      
      // 上序合格数取最大值（保持不变）
      const shxnum = group.map(item => item.上序合格数 || 0);
      mergedItem.上序合格数 = Math.max(...shxnum);
      
      // 计算执行状态：只要一组内包含订单行号=1 或者包含上序合格数>0，都属于可执行（保持不变）
      const hasFirstProcess = group.some(item => item.订单行号 === 1);
      const hasPreviousQualified = group.some(item => (item.上序合格数 || 0) > 0);
      mergedItem.执行状态 = (hasFirstProcess || hasPreviousQualified) ? 1 : 2;
      
      // 存储原始组数据引用
      mergedItem.originalGroup = group;
      
      return mergedItem;
    },
    // ============ 工具方法 ============
    
    
    getCurrentUser() {
      return this.$store.state.user.name
    },
    
    formatDateTime(dateTime) {
      if (!dateTime) return ''
      const date = new Date(dateTime)
      return date.toLocaleString('zh-CN', { 
        year: 'numeric', 
        month: '2-digit', 
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit',
        hour12: false
      }).replace(/\//g, '-')
    },

  }
}
</script>

<style scoped>
.search-container {
  display: flex;
  align-items: center;
  flex-wrap: wrap;
  gap: 10px;
}

.show-text {
  white-space: nowrap;
}

.custom-tabs {
  margin-top: 10px;
}

.dialog-footer {
  text-align: center;
}

/* ::v-deep .row-without-endtime {
  background-color: #f56c6c !important;
  color: #000000 !important;
} */
</style>