gxt_app/pages/score/detail/reEvaluate.uvue

<template>
  <uni-navbar-lite :showLeft="true" title="工单复评">
    <view class="back-icon" slot="left" @click="goBack">
      <text class="iconfont icon-back">{{ orderType == '1' ? '维修工单复评' : '维保工单复评' }}</text>
    </view>
  </uni-navbar-lite>
  
  <scroll-view class="container" :scroll-y="true">
    <view class="header">
      <text class="title"></text>
    </view>
    
    <view class="form">
      <!-- 工单基本信息 -->
      <view class="info-card">
        <view class="info-item">
          <text class="info-label">工单编码</text>
          <text class="info-value">{{ reEvaluationForm.workOrderProjectNo }}</text>
        </view>
        <view class="info-item">
          <text class="info-label">风机编号</text>
          <text class="info-value">{{ reEvaluationForm.pcsDeviceName }}</text>
        </view>
        <view class="info-item">
          <text class="info-label">场站</text>
          <text class="info-value">{{ reEvaluationForm.pcsStationName }}</text>
        </view>
		<!-- 工单类型相关字段 -->
		<view class="info-item" v-if="reEvaluationForm.orderType == '1'">
		  <text class="info-label">检修类型</text>
		  <text class="info-value">{{ getMaintenanceTypeLabel(reEvaluationForm.maintenanceType) }}</text>
		</view>
		<view class="info-item" v-if="reEvaluationForm.orderType == '2'">
		  <text class="info-label">维保类型</text>
		  <text class="info-value">
		    <text v-for="(type, index) in reEvaluationForm.inspectionType" :key="index">
		      {{ getInspectionTypeLabel(type) }}&nbsp;
		    </text>
		  </text>
		</view>
		<view class="info-item">
		  <text class="info-label">{{ reEvaluationForm.orderType == '1' ? '维修总结' : '维保总结' }}</text>
		  <text class="info-value">{{ reEvaluationForm.workSummary }}</text>
		</view> 
		<!-- 额外工作总结 - 仅维修工单显示 -->
		<view v-if="reEvaluationForm.orderType == '1'" class="info-item">
		  <text class="info-label">额外工作总结</text>
		  <text class="info-value">{{ reEvaluationForm.extraWork }}</text>
		</view>
		
		<view class="info-item" v-if="reEvaluationForm.orderType == '2'">
		  <text class="info-label">分项完成系数和</text>
		  <text class="info-value">{{ reEvaluationForm.itemCompletionFactorSum }}</text>
		</view>

		<view class="info-item"  v-if="reEvaluationForm.orderType == '2'">
           <text class="info-label">分项完成系数<text style="color: red;">*</text></text>
           <input
            class="info-input"
            type="digit"
            :value="getItemCompletionFactorDisplayValue()"
            @input="onItemCompletionFactorInput"
            @blur="formatItemCompletionFactor()"
            placeholder="请输入分项完成系数"
            />
        </view>
      </view>

      <!-- 退回理由 -->
	 <!-- <view class="info-card">
        <view class="form-item">
          <text class="label">退回理由</text>
          <textarea 
            class="textarea" 
            :value="reEvaluationForm.scoreReturnReason"
            @input="onReturnReasonInput"
            placeholder="请输入退回理由"
            :maxlength="500"
          />
        </view>
      </view> -->

      
      <view class="info-card" v-if="showModifyReason">
		  <!-- 修改理由 - 仅当需要修改时显示 -->
        <view class="form-item" >
          <text class="label">修改理由<text style="color: red;">*</text></text>
          <textarea 
            class="textarea" 
            :value="reEvaluationForm.modifyReason"
            @input="onModifyReasonInput"
            placeholder="请输入修改理由"
            :maxlength="200"
          />
        </view>
      </view>

      <!-- 反馈理由 - 仅当有反馈理由时显示 -->
      <view v-if="showFeedbackReason" class="info-card">
        <view class="info-item">
          <text class="info-label">反馈理由</text>
          <text class="info-value">{{ (reEvaluationForm.feedbackReason != null) ? reEvaluationForm.feedbackReason : '' }}</text>
        </view>
      </view>

      <!-- 外委人员数和外来人员数 -->
      <!-- <view class="info-card">
        <view class="info-item-row">
          <view class="info-item-half">
            <text class="info-label">外委人员数（人）</text>
            <text class="info-value">{{ reEvaluationForm.wwryNum.toString() }}</text>
          </view>
          <view class="info-item-half">
            <text class="info-label">外来人员数（人）</text>
            <text class="info-value">{{ reEvaluationForm.wlryNum.toString() }}</text>
          </view>
        </view>
      </view> -->

      <!-- 人员信息和得分明细 -->
      <view class="info-card">
        <view class="form-item">
          <text class="label">得分明细 ({{ isMixedZeroNonZeroInspectionTypes() ? '最少可评总分: ' : '可复评总分: ' }}{{ getReviewEvaluationTotalScore() == 0 ? '未规定' : getReviewEvaluationTotalScore().toFixed(2) + '分' }}, 已复评总分: {{ getReEvaluatedTotalScore().toFixed(2) }}分)</text>
        </view>
        <view v-for="(person, index) in reEvaluationForm.scorePersonList as UTSJSONObject[]" :key="index" class="person-score-item">
          <view class="person-info">
            <text class="person-name">{{ (person as UTSJSONObject).get('nickName') }}<text v-if="(person as UTSJSONObject).get('isLeader') == 1"> (工作负责人)</text></text>
          </view>
          <view class="score-inputs">
            <view class="score-item">
              <text class="score-label">检修工分</text>
              <text class="score-value">{{ getPersonScore(person, 'selfScore') }}</text>
            </view>
            <view class="score-item">
              <text class="score-label">复评得分<text style="color: red;">*</text></text>
              <input 
                class="score-input" 
                type="digit" 
                :value="getPersonScore(person, 'reviewScore')" 
                @input="onScoreInput($event, index, 'reviewScore')"
                @blur="formatScoreInput(index, 'reviewScore'); onScoreChange()"
                placeholder="0.00" 
              />
            </view>
            <!-- 额外工分 - 仅当维修工单且有额外工作总结时显示 -->
            <view v-if="reEvaluationForm.orderType == '1' && hasExtraWorkFlag" class="score-item">
              <text class="score-label">额外工分</text>
              <!-- <input 
                class="score-input" 
                type="digit" 
                :value="getPersonScore(person, 'extraScore')" 
                @input="onScoreInput($event, index, 'extraScore')"
                @blur="formatScoreInput(index, 'extraScore'); onScoreChange()"
                placeholder="0.00" 
              /> -->
			  <text class="score-value">{{ getPersonScore(person, 'extraScore') }}</text>
            </view> 
            <!-- 工单得分 - 仅当维修工单且有额外工作总结时显示 -->
            <view v-if="reEvaluationForm.orderType == '1' && hasExtraWorkFlag" class="score-item">
              <text class="score-label">工单得分</text>
              <input 
                class="score-input" 
                type="digit" 
                :value="getPersonScore(person, 'totalScore')" 
                readonly
                disabled
                placeholder="自动计算" 
                style="pointer-events: none;"
              />
            </view>
            <!-- 额外工分和工单得分 - 仅当维保工单且维保类型包含其他/其它时显示 -->
            <view v-if="reEvaluationForm.orderType == '2' && hasOtherOrQitaInspectionType()" class="score-item">
              <text class="score-label">额外工分</text>
              <!-- <input
                class="score-input"
                type="digit" 
                :value="getPersonScore(person, 'extraScore')" 
                @input="onScoreInput($event, index, 'extraScore')"
                @blur="formatScoreInput(index, 'extraScore'); onScoreChange()"
                placeholder="0.00" 
              /> -->
			  <text class="score-value">{{ getPersonScore(person, 'extraScore') }}</text>
            </view> 
            <view v-if="reEvaluationForm.orderType == '2' && hasOtherOrQitaInspectionType()" class="score-item">
              <text class="score-label">工单得分</text>
              <input 
                class="score-input" 
                type="digit" 
                :value="getPersonScore(person, 'totalScore')" 
                readonly
                disabled
                placeholder="自动计算" 
                style="pointer-events: none;" 
              />
            </view>
          </view>
        </view>
      </view>
      
    </view>
  </scroll-view>

  <!-- 提交按钮固定在底部 -->
  <view class="button-group">
    <view v-if="hasReturnReason" class="warning-btn" @click="submitReturn">
      <text class="btn-text">退 回</text>
    </view>
    <view v-if="!hasReturnReason" class="submit-btn" @click="submitReEvaluationForm">
      <text class="submit-text">提交复评</text>
    </view>
  </view>
</template>

<script setup lang="uts">
import { ref, computed } from 'vue'
import { onLoad } from '@dcloudio/uni-app';
import { getOrderScoreDetail, submitReEvaluation, getMaintenanceTypes, listInspectionTypesByFanType } from '@/api/score/index'
import { getDictDataByType } from '@/api/dict/index'
import type { SysDictData } from '@/types/dict'

// 页面参数
const id = ref<string>('')
const orderType = ref<string>('')
// 添加额外工作总结状态变量
const hasExtraWorkFlag = ref<boolean>(false)
// 控制显示退回理由
const showReturnReason = ref<boolean>(false)
// 显示修改理由
const showModifyReason = ref<boolean>(false)

// 检查是否存在复评分数与自评分数不同的情况
const hasDifferentReviewAndSelfScore = ref<boolean>(false)
// 显示反馈理由
const showFeedbackReason = ref<boolean>(false)

// 控制是否显示退回按钮
const hasReturnReason = ref<boolean>(false)

// 临时存储分项完成系数的原始输入值
const tempItemCompletionFactorInput = ref<string>('')

// 验证规则 - 使用UTS兼容的简单对象定义
const validationRules: any = { 
  scoreReturnReason: [
    { required: true, message: "退回理由不能为空", trigger: "blur" }
  ], 
}

// 复评表单数据
type ReEvaluationFormData = {
  orderType: string
  id: number
  workOrderProjectNo: string
  pcsDeviceName: string
  pcsStationName: string
  model: string | null  // 风机型号，用于获取维保类型选项
  workSummary: string  // 总结内容
  extraWork: string    // 额外工作总结
  maintenanceType: string | null
  inspectionType: string[]
  itemCompletionFactor: number | null
  itemCompletionFactorSum: number
  scorePersonList: UTSJSONObject[]
  wwryNum: number
  wlryNum: number
  reviewScoreNum: number  // 复评次数
  scoreReturnReason: string | null // 退回理由
  modifyReason: string | null     // 修改理由
  feedbackReason: string | null   // 反馈理由
  initialMaintenanceType: string | null // 初始检修类型，用于判断是否修改
  initialItemCompletionFactor: number | null   // 初始分项完成系数，用于判断是否修改
}

// 添加响应式变量来跟踪已复评总分
let reEvaluatedTotalScore = ref<number>(0)

const reEvaluationForm = ref<ReEvaluationFormData>({
  orderType: '',
  id: 0,
  workOrderProjectNo: '',
  pcsDeviceName: '',
  pcsStationName: '',
  model: null as string | null,
  workSummary: '',
  extraWork: '',
  maintenanceType: null,
  inspectionType: [],
  itemCompletionFactor: 1.0,
  itemCompletionFactorSum: 1.0,
  scorePersonList: [],
  wwryNum: 0,
  wlryNum: 0,
  reviewScoreNum: 0,
  scoreReturnReason: '',
  modifyReason: '',
  feedbackReason: '',
  initialMaintenanceType: null,
  initialItemCompletionFactor: 1.0
})

type MaintenanceTypeOption = {
  value: string
  label: string
}
// 检修类型选项
const maintenanceTypeOptions = ref<MaintenanceTypeOption[]>([])

// 维保类型选项
const inspectionTypeOptions = ref<UTSJSONObject[]>([])

// 维保类型字典
const inspectionTypeDictList = ref<SysDictData[]>([])

// 检查字符串是否只包含空白字符
function isWhitespaceOnly(str: string): boolean {
  if (str == null) return true;
  for (let i = 0; i < str.length; i++) {
    const char = str.charAt(i);
    if (char != ' ' && char != '\t' && char != '\n' && char != '\r') {
      return false;
    }
  }
  return true;
}

// 监听scoreReturnReason的变化来更新hasReturnReason
import { watch } from 'vue'

watch(reEvaluationForm, (newForm: ReEvaluationFormData) => {
  hasReturnReason.value = newForm.scoreReturnReason != null && !isWhitespaceOnly(newForm.scoreReturnReason as string);
}, { deep: true })

// 检查是否存在复评分数与自评分数不同的情况
function checkDifferentReviewAndSelfScore(): boolean {
  const scorePersonList = reEvaluationForm.value.scorePersonList as UTSJSONObject[]
  if (scorePersonList == null || scorePersonList.length == 0) {
    return false;
  }

  for (let i = 0; i < scorePersonList.length; i++) {
    const person = scorePersonList[i]
    const reviewScore = person.get('reviewScore')
    const selfScore = person.get('selfScore')
    
    // 如果复评分数或自评分数为空，则跳过比较
    if (reviewScore == null || selfScore == null || reviewScore == '' || selfScore == '') {
      continue;
    }
    
    // 统一转换为数值进行比较
    let reviewScoreNum = 0;
    let selfScoreNum = 0;
    
    if (typeof reviewScore == 'number') {
      reviewScoreNum = reviewScore as number;
    } else {
      reviewScoreNum = parseFloat(reviewScore as string);
    }
    
    if (typeof selfScore == 'number') {
      selfScoreNum = selfScore as number;
    } else {
      selfScoreNum = parseFloat(selfScore as string);
    }
    
    // 比较数值是否不同（考虑浮点数精度问题）
    if (Math.abs(reviewScoreNum - selfScoreNum) > 0.001) {
      return true;
    }
  }
  
  return false;
}

// 获取已复评总分
function getReEvaluatedTotalScore(): number {
  const scorePersonList = reEvaluationForm.value.scorePersonList as UTSJSONObject[]
  if (scorePersonList == null || scorePersonList.length == 0) {
    return 0
  }

  let totalReScore = 0

  for (let i = 0; i < scorePersonList.length; i++) {
    const person = scorePersonList[i]
    const reviewScoreVal = person.get('reviewScore')
    if (reviewScoreVal != null) {
      let score = 0;
      if (typeof reviewScoreVal == 'number') {
        score = reviewScoreVal as number;
      } else if (typeof reviewScoreVal == 'string' && (reviewScoreVal as string) != '') {
        score = parseFloat(reviewScoreVal as string);
      }
      if (!isNaN(score)) {
        totalReScore += score
      }
    }
  }

  return totalReScore
}



// 更新已复评总分的响应式变量
function updateReEvaluatedTotalScore(): void {
  reEvaluatedTotalScore.value = getReEvaluatedTotalScore()
}

// 更新总分
function updateTotalScores(): void {
  const scorePersonList = reEvaluationForm.value.scorePersonList as UTSJSONObject[]
  if (scorePersonList == null || scorePersonList.length == 0) return

  for (let i = 0; i < scorePersonList.length; i++) {
    const person = scorePersonList[i]
    const reviewScoreVal = person.get('reviewScore')
    const extraScoreVal = person.get('extraScore')

    // 如果有额外工分，则计算总分 = 复评得分 + 额外工分
    // 注意：复评阶段额外工分为只读，不应当修改
    if (extraScoreVal != null && extraScoreVal != '' && reviewScoreVal != null && reviewScoreVal != ''){
      // 正确处理数值类型
      let extraScoreNum = 0;
      if (typeof extraScoreVal == 'number') {
        extraScoreNum = extraScoreVal as number;
      } else {
        extraScoreNum = parseFloat(extraScoreVal as string);
      }
      
      let reviewScoreNum = 0;
      if (typeof reviewScoreVal == 'number') {
        reviewScoreNum = reviewScoreVal as number;
      } else {
        reviewScoreNum = parseFloat(reviewScoreVal as string);
      }
      
      const totalScore = parseFloat((reviewScoreNum + extraScoreNum).toFixed(2));
      person.set('totalScore', totalScore);
    }else if(reviewScoreVal != null && reviewScoreVal != ''){
      let reviewScoreNum = 0;
      if (typeof reviewScoreVal == 'number') {
        reviewScoreNum = reviewScoreVal as number;
      } else {
        reviewScoreNum = parseFloat(reviewScoreVal as string);
      }
      person.set('totalScore', reviewScoreNum);
    } else {
      person.set('totalScore', null);
    }
  }

  // 更新已复评总分显示
  updateReEvaluatedTotalScore()
}

// 计算得分 - 实际上在复评中，这是手动输入的，不需要自动计算
function calculateScores(): void {
  // 在复评阶段，分数是手动输入的，不需要自动计算
  // 但我们需要根据工单类型和配置来验证总分是否符合规则
  updateTotalScores()
  
  // 更新已复评总分显示
  updateReEvaluatedTotalScore()
}

// 根据值获取维保类型标签
function getInspectionTypeLabel(value: string): string {
  if (value == '') return ''
  const list = inspectionTypeDictList.value
  for (let i = 0; i < list.length; i++) {
    const item = list[i]
    if (item.dictValue == value) {
        return (item.dictLabel != null ? item.dictLabel : value) as string
    }
  }
  return value
}

// 检查维保类型是否包含'其他'或'其它'选项
function hasOtherOrQitaInspectionType(): boolean {
  if (reEvaluationForm.value.orderType != '2') return false
  if (!Array.isArray(reEvaluationForm.value.inspectionType)) return false
  
  for (let i = 0; i < reEvaluationForm.value.inspectionType.length; i++) {
    const typeId = reEvaluationForm.value.inspectionType[i]
    const label = getInspectionTypeLabel(typeId)
    if (label == '其他' || label == '其它') {
      return true
    }
  }
  return false
}

// 检查当前上下文中的表单对象是否包含其他或其它选项
function hasOtherOrQitaInspectionTypeInCurrentForm(): boolean {
  if (reEvaluationForm.value.orderType != '2') return false
  if (!Array.isArray(reEvaluationForm.value.inspectionType)) return false
  
  const selectedInspectionTypes = (reEvaluationForm.value.inspectionType != null) ? reEvaluationForm.value.inspectionType : [];
  const inspectionTypeArray =  inspectionTypeDictList.value;
  for (let i = 0; i < selectedInspectionTypes.length; i++) {
    const typeId = selectedInspectionTypes[i];
    const dictItem = inspectionTypeArray.find(item => item != null && item.dictValue != null && item.dictValue == typeId);
    if (dictItem != null && dictItem.dictLabel != null) {
      const labelName = dictItem.dictLabel.trim();
      if (labelName == '其他' || labelName == '其它') {
        return true;
      }
    } 
  }
  return false;
}

// 根据值获取检修类型标签
function getMaintenanceTypeLabel(value: string | null): string {
  if (value == null || value == '') return ''
  const item = maintenanceTypeOptions.value.find(item => item.value == value)
  return item != null ? item.label : value
}

// 人员评分验证
function validatePersonScore(score: string, fieldName: string): string | null {
  if (score == null || score == '') {
    if (fieldName == 'reviewScore') {
      return '复评得分不能为空';
    }
    return null; // 额外工分可以为空
  }
  
  const numScore = parseFloat(score as string);
  if (isNaN(numScore)) {
    return `${fieldName == 'reviewScore' ? '复评得分' : '额外工分'}必须为数字`;
  }
  
  if (numScore < 0) {
    return `${fieldName == 'reviewScore' ? '复评得分' : '额外工分'}不能小于0`;
  }
  
  if (fieldName == 'reviewScore' && numScore <= 0) {
    return '复评得分必须大于0';
  }

  return null;
}

// 字段验证函数
function validateField(fieldName: string, value: any): string | null {
  console.log('验证字段:', fieldName, '值:', value);
  // 根据字段名称确定验证规则
  if (fieldName == 'scoreReturnReason') {
    // 验证退回理由
    if (value == null || value == '' || isWhitespaceOnly(value as string)) {
      return '退回理由不能为空';
    }
  } else if (fieldName == 'modifyReason') {
    // 验证修改理由
    if (value == null || value == '' || isWhitespaceOnly(value as string)) {
      return '修改理由不能为空';
    }
  }

  return null;
}

// 获取维修工单总分 - 用于验证
function getRepairTotalScoreForValidation(): number {
  // 对于维修工单，我们通常从maintenanceType获取对应分值
  if (reEvaluationForm.value.maintenanceType == null) {
    return 0;
  }
  
  // 在选项中查找对应类型
  const foundOption = maintenanceTypeOptions.value.find(item => item.value == reEvaluationForm.value.maintenanceType);
  if (foundOption != null) {
    // 从标签中提取分数（格式如"项目名称(2.00分)"）
    const regex = /\((\d+\.?\d*)分\)/;
    // 确保label被正确转换为字符串
    const labelStr = foundOption.label != null ? foundOption.label.toString() : '';
    const match = regex.exec(labelStr);
    if (match != null && match.length > 1 && match[1] != null) {
      return parseFloat(match[1] as string);
    }
  }
  
  return 0;
}

// 获取维保工单总分 - 用于验证
function getMaintenanceTotalScoreForValidation(): number {
  // 对于维保工单，根据维保类型和分项完成系数计算
  if (!Array.isArray(reEvaluationForm.value.inspectionType) || reEvaluationForm.value.inspectionType.length == 0) {
    return 0;
  }
  
  let totalScoreFromDB = 0;
  
  // 遍历选中的维保类型，累加分值
  for (let i = 0; i < reEvaluationForm.value.inspectionType.length; i++) {
    const typeId = reEvaluationForm.value.inspectionType[i];
    // 从选项中查找对应的分值 - 参考index.vue的实现
    const optionItem = inspectionTypeOptions.value.find(item => {
      // 检查UTSJSONObject中是否有inspectionTypeId字段
      const inspectionTypeId = (item.get('inspectionTypeId') as string | number | null);
      return inspectionTypeId != null && inspectionTypeId.toString() == typeId;
    });
    if (optionItem != null) {
      // 检查是否有score字段
      const rawScore = optionItem.get('score');
      let score: number;
      if (typeof rawScore == 'number') {
        score = rawScore as number;
      } else if (typeof rawScore == 'string') {
        score = parseFloat(rawScore as string);
      } else {
        continue; // 如果不是数值也不是字符串，跳过此项
      }
      if (!isNaN(score)) {
        totalScoreFromDB += score;
      }
    }
  }
  
  // 应用分项完成系数 - 处理可能为null的情况
  const completionFactor = (reEvaluationForm.value.itemCompletionFactor != null) ? reEvaluationForm.value.itemCompletionFactor : 1;
  return totalScoreFromDB * (completionFactor as number);
}

// 获取工单总分 - 用于验证
function getTotalScoreForValidation(): number {
  if (reEvaluationForm.value.orderType == '1') {
    // 维修工单
    return getRepairTotalScoreForValidation();
  } else {
    // 维保工单
    return getMaintenanceTotalScoreForValidation();
  }
}

// 判断是否为多选维保类型且存在零分和非零分混合的情况 - 通用函数
function isMixedZeroNonZeroInspectionTypes(): boolean {
  if (reEvaluationForm.value.orderType == '2' && 
      Array.isArray(reEvaluationForm.value.inspectionType) && 
      reEvaluationForm.value.inspectionType.length > 1) {
    
    const selectedInspectionTypes = (reEvaluationForm.value.inspectionType != null) ? reEvaluationForm.value.inspectionType : [];
    let hasZeroScore = false;
    let hasNonZeroScore = false;
    
    if (Array.isArray(selectedInspectionTypes) && selectedInspectionTypes.length > 0) {
      for (let i = 0; i < selectedInspectionTypes.length; i++) {
        const typeId = selectedInspectionTypes[i];
        // 从选项中查找对应的分值 - 参考index.vue的实现
        const optionItem = inspectionTypeOptions.value.find(item => {
          // 检查UTSJSONObject中是否有inspectionTypeId字段
          const inspectionTypeId = (item.get('inspectionTypeId') as string | number | null);
          return inspectionTypeId != null && inspectionTypeId.toString() == typeId;
        });
        if (optionItem != null) {
          // 检查是否有score字段
          const rawScore = optionItem.get('score');
          let score: number;
          if (typeof rawScore == 'number') {
            score = rawScore as number;
          } else if (typeof rawScore == 'string') {
            score = parseFloat(rawScore as string);
          } else {
            continue; // 如果不是数值也不是字符串，跳过此项
          }
          if (!isNaN(score)) {
            if (score == 0) {
              hasZeroScore = true;
            } else if (score > 0) {
              hasNonZeroScore = true;
            }
          }
        }
      }
    }
    
    // 如果既有零分又有非零分，则返回true
    return hasZeroScore && hasNonZeroScore;
  }
  return false;
}

// 获取可复评总分
function getReviewEvaluationTotalScore(): number {
  // 获取工单总分
  const totalScore = getTotalScoreForValidation();
  
  // 如果总分为0，返回0
  if (totalScore == 0) {
    // 特殊处理：对于维保工单且多选维保类型的情况，如果存在零分和非零分的混合情况
    if (reEvaluationForm.value.orderType == '2' && 
        Array.isArray(reEvaluationForm.value.inspectionType) && 
        reEvaluationForm.value.inspectionType.length > 1) {
      
      const selectedInspectionTypes = (reEvaluationForm.value.inspectionType != null) ? reEvaluationForm.value.inspectionType : [];
      
      // 计算所有选中维保类型的非零分值
      let minScoreFromDB = 0; // 非零分值总和
      let hasZeroScore = false; // 是否存在零分
      
      if (selectedInspectionTypes != null && selectedInspectionTypes.length > 0) {
        for (let i = 0; i < selectedInspectionTypes.length; i++) {
          const typeId = selectedInspectionTypes[i];
          // 从选项中查找对应的分值 - 参考index.vue的实现
          const optionItem = inspectionTypeOptions.value.find(item => {
            // 检查UTSJSONObject中是否有inspectionTypeId字段
            const inspectionTypeId = (item.get('inspectionTypeId') as string | number | null);
            return inspectionTypeId != null && inspectionTypeId.toString() == typeId;
          });
          if (optionItem != null) {
            // 检查是否有score字段
            const rawScore = optionItem.get('score');
            let score: number;
            if (typeof rawScore == 'number') {
              score = rawScore as number;
            } else if (typeof rawScore == 'string') {
              score = parseFloat(rawScore as string);
            } else {
              continue; // 如果不是数值也不是字符串，跳过此项
            }
            if (!isNaN(score)) {
              if (score == 0) {
                hasZeroScore = true;
              } else if (score > 0) {
                minScoreFromDB += score;
              }
            }
          }
        }
      }
      
      // 如果存在零分且存在非零分的情况，返回非零分的总和加上工作负责人的0.5分
      if (hasZeroScore && minScoreFromDB > 0) {
        const completionFactor = (reEvaluationForm.value.itemCompletionFactor != null) ? reEvaluationForm.value.itemCompletionFactor : 1;
        return (minScoreFromDB * (completionFactor as number)) + 0.5;
      }
    }
    return 0;
  }
  
  // 返回总分+0.5（工作负责人额外加0.5分）
  return totalScore + 0.5;
}

// 验证评分规则
function validateScoringRules(): any {
  // 获取工单总分
  const totalScore = getTotalScoreForValidation();

  // 获取复评得分总和
  const totalReScore = getReEvaluatedTotalScore()

  const scorePersonList = reEvaluationForm.value.scorePersonList as UTSJSONObject[]
  if (scorePersonList == null || scorePersonList.length == 0) {
    const result = new UTSJSONObject();
    result.set('valid', true);
    result.set('message', '');
    return result;
  }

  // 检查每个人员的评分
  let hasEmptyScore = false;
  let leaderScore: number | null = null;
  
  // 计算总得分
  let totalScoreValue = 0;
  
  for (let i = 0; i < scorePersonList.length; i++) {
    const person = scorePersonList[i];

    // 验证复评得分
    const reviewScore = person.get('reviewScore');
    if (reviewScore == null || reviewScore == '') {
      hasEmptyScore = true;
    } else {
      // 统一处理分数类型
      let scoreStr = '';
      if (typeof reviewScore == 'number') {
        scoreStr = reviewScore.toString(); 
      } else {
        scoreStr = reviewScore as string;
      }
      const validationError = validatePersonScore(scoreStr, 'reviewScore');
      if (validationError != null) {
        const result = new UTSJSONObject();
        result.set('valid', false);
        result.set('message', `${person.get('nickName')}：${validationError}`);
        return result;
      }

      const score = parseFloat(scoreStr as string);
      if (!isNaN(score)) {
        // 检查得分是否大于0
        if (score <= 0) {
          const result = new UTSJSONObject();
          result.set('valid', false);
          result.set('message', `每个人的得分必须大于0（${person.get('nickName')}的得分为${score}）`);
          return result;
        }
        totalScoreValue += score;
        if (person.get('isLeader') != null && person.get('isLeader') as number == 1) {
          leaderScore = score;
        }
      }
    }

    // 验证额外工分（如果存在）
    const extraScore = person.get('extraScore');
    if (extraScore != null && extraScore != '') {
      // 统一处理分数类型
      let extraScoreStr = '';
      if (typeof extraScore == 'number') {
        extraScoreStr = extraScore.toString(); 
      } else {
        extraScoreStr = extraScore as string;
      }
      const extraScoreError = validatePersonScore(extraScoreStr, 'extraScore');
      if (extraScoreError != null) {
        const result = new UTSJSONObject();
        result.set('valid', false);
        result.set('message', `${person.get('nickName')}：${extraScoreError}`);
        return result;
      }
    }
  }

  // 如果有人没评分，返回错误
  if (hasEmptyScore) {
    const result = new UTSJSONObject();
    result.set('valid', false);
    result.set('message', '部分人员未评分');
    return result;
  }
  
  // 如果总分为0，则评分无上限
  if (totalScore == 0) {
    // 检查工作负责人得分-0.5后是否小于等于0
    if (leaderScore != null) {
      const leaderScoreAfterReduction = leaderScore - 0.5;
      if (leaderScoreAfterReduction <= 0) {
        const result = new UTSJSONObject();
        result.set('valid', false);
        result.set('message', `工作负责人得分减去0.5后不能小于等于0（当前：${leaderScore.toFixed(2)} - 0.5 = ${leaderScoreAfterReduction.toFixed(2)}）`);
        return result;
      }
    }
    
    const result = new UTSJSONObject();
    result.set('valid', true);
    result.set('message', '');
    return result;
  }
  
  // 对于维保工单且多选维保类型的情况，需要特殊处理
  if (reEvaluationForm.value.orderType == '2' && 
      Array.isArray(reEvaluationForm.value.inspectionType) && 
      reEvaluationForm.value.inspectionType.length > 1) {
    // 获取选中的维保类型
    const selectedInspectionTypes = (reEvaluationForm.value.inspectionType != null) ? reEvaluationForm.value.inspectionType : [] as string[];
    
    // 计算所有选中维保类型的总分值
    let minScoreFromDB = 0; // 最低分值（非零）
    let hasZeroScore = false; // 是否存在零分
    
    if (Array.isArray(selectedInspectionTypes) && selectedInspectionTypes.length > 0) {
      for (let i = 0; i < selectedInspectionTypes.length; i++) {
        const typeId = selectedInspectionTypes[i];
        // 从选项中查找对应的分值 - 参考index.vue的实现
        const optionItem = inspectionTypeOptions.value.find(item => {
          // 检查UTSJSONObject中是否有inspectionTypeId字段
          const inspectionTypeId = (item.get('inspectionTypeId') as string | number | null);
          return inspectionTypeId != null && inspectionTypeId.toString() == typeId;
        });
        if (optionItem != null) {
          // 检查是否有score字段
          const rawScore = optionItem.get('score');
          let score: number;
          if (typeof rawScore == 'number') {
            score = rawScore as number;
          } else if (typeof rawScore == 'string') {
            score = parseFloat(rawScore as string);
          } else {
            continue; // 如果不是数值也不是字符串，跳过此项
          }
          if (!isNaN(score)) {
            if (score == 0) {
              hasZeroScore = true;
            } else if (score > 0) {
              minScoreFromDB += score;
            }
          }
        }
      }
    }
    
    // 如果存在零分且存在非零分的情况
    if (hasZeroScore && minScoreFromDB > 0) {
      // 获取分项完成系数 - 处理可能为null的情况
      const completionFactor = (reEvaluationForm.value.itemCompletionFactor != null) ? reEvaluationForm.value.itemCompletionFactor : 1;
      // 计算最低理论总分（非零项的总分 * 分项完成系数 + 0.5）
      const minExpectedTotal = (minScoreFromDB * (completionFactor as number)) + 0.5;
      
      // 检查工作负责人得分-0.5后是否小于等于0
      if (leaderScore != null) {
        const leaderScoreAfterReduction = leaderScore - 0.5;
        if (leaderScoreAfterReduction <= 0) {
          const result = new UTSJSONObject();
          result.set('valid', false);
          result.set('message', `工作负责人得分减去0.5后不能小于等于0（当前：${leaderScore.toFixed(2)} - 0.5 = ${leaderScoreAfterReduction.toFixed(2)}）`);
          return result;
        }
      }
      
      const result = new UTSJSONObject();
      result.set('valid', true);
      result.set('message', '');
      return result;
    }
  }
  
  // 计算理论总分（总分+0.5）
  const expectedTotal = totalScore + 0.5;

  // 总得分必须小于等于理论总分
  if (totalScoreValue - expectedTotal > 0.01) {  // 使用0.01作为容差
    const result = new UTSJSONObject();
    result.set('valid', false);
    result.set('message', `总得分必须小于等于 ${expectedTotal.toFixed(2)} 分（当前：${totalScoreValue.toFixed(2)} 分）`);
    return result;
  }
  
  // 检查工作负责人得分-0.5后是否小于等于0
  if (leaderScore != null) {
    const leaderScoreAfterReduction = leaderScore - 0.5
    if (leaderScoreAfterReduction <= 0) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', `工作负责人得分减去0.5后不能小于等于0（当前：${leaderScore.toFixed(2)} - 0.5 = ${leaderScoreAfterReduction.toFixed(2)}）`);
      return result;
    }
  }

  const result = new UTSJSONObject();
  result.set('valid', true);
  result.set('message', '');
  return result;
}

// 验证整个表单
function validateForm(): any {
  // 如果有退回理由，需要验证退回理由
  if (hasReturnReason.value) {
    let returnReasonValidation: string | null = null;
    try {
      returnReasonValidation = validateField('scoreReturnReason', reEvaluationForm.value.scoreReturnReason as any);
    } catch (error: any) {
      console.error('退回理由验证过程中出现异常:', error);
      returnReasonValidation = '退回理由验证失败';
    }
    if (returnReasonValidation != null) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', returnReasonValidation);
      return result;
    }
  }
  
  // 检查是否修改了检修类型但未填写修改理由
  if (reEvaluationForm.value.orderType == '1' && 
      reEvaluationForm.value.maintenanceType != reEvaluationForm.value.initialMaintenanceType &&
      (reEvaluationForm.value.modifyReason == null || isWhitespaceOnly(reEvaluationForm.value.modifyReason as string))) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', '修改了检修类型，请填写修改理由');
      return result;
  }
  
  // 验证分项完成系数不为空 - 仅适用于维保工单
  if (reEvaluationForm.value.orderType == '2' && 
      (reEvaluationForm.value.itemCompletionFactor == null || 
       typeof reEvaluationForm.value.itemCompletionFactor != 'number' ||
       isNaN(reEvaluationForm.value.itemCompletionFactor as number))) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', '分项完成系数不能为空');
      return result;
  }
  
  // 检查是否修改了分项完成系数但未填写修改理由
  if (reEvaluationForm.value.orderType == '2' && 
      (reEvaluationForm.value.itemCompletionFactor != reEvaluationForm.value.initialItemCompletionFactor) &&
      (reEvaluationForm.value.modifyReason == null || isWhitespaceOnly(reEvaluationForm.value.modifyReason as string))) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', '修改了分项完成系数，请填写修改理由');
      return result;
  }
  
  // 检查是否存在复评分数与自评分数不同但未填写修改理由的情况
  if (checkDifferentReviewAndSelfScore() && 
      (reEvaluationForm.value.modifyReason == null || isWhitespaceOnly(reEvaluationForm.value.modifyReason as string))) {
      const result = new UTSJSONObject();
      result.set('valid', false);
      result.set('message', '复评分数与自评分数不同，请填写修改理由');
      return result;
  }

  // 验证评分规则
  let scoringValidation: UTSJSONObject;
	try {
	  scoringValidation = validateScoringRules() as UTSJSONObject;
	} catch (error: any) {
	  console.error('评分规则验证过程中出现异常:', error);
	  const result = new UTSJSONObject();
	  result.set('valid', false);
	  result.set('message', '评分规则验证失败');
	  return result;
	}
	if (!(scoringValidation.get('valid') as boolean)) {
	  const result = new UTSJSONObject();
	  result.set('valid', false);
	  result.set('message', scoringValidation.get('message') as string);
	  return result;
	}

	const result = new UTSJSONObject();
  result.set('valid', true);
  result.set('message', '');
  return result;
}

// 加载检修类型选项
async function loadMaintenanceTypes() { 
  try {
    uni.showLoading({
      title: '加载中...'
    })
    
    const response: any = await getMaintenanceTypes()
    const resultObj = response as UTSJSONObject
    const code = resultObj.get('code') as number
    
    if (code == 200) {
      const data = resultObj.get('rows') as UTSJSONObject[]
      if (data != null && Array.isArray(data)) {
        // 将后端返回的数据转换为页面需要的格式
        const options: MaintenanceTypeOption[] = []
        for (let i = 0; i < data.length; i++) {
          const item = data[i]
          const option: MaintenanceTypeOption = {
            value: (item.get('maintenanceType') as string | null) ?? '',
            label: `${(item.get('projectName') as string | null) ?? ''}(${(item.get('scorePerCompletion') as number | null) ?? 0}分)`
          }
          options.push(option)
        }
        maintenanceTypeOptions.value = options
      }
    } else { 
      const msg = resultObj.get('msg') as string | null
      console.error('加载检修类型失败:', msg ?? '未知错误')
    }
  } catch (error: any) {
    console.error('加载检修类型失败:', error)
  } finally {
    uni.hideLoading()
  }
}

// 加载维保类型选项
async function loadInspectionTypeOptions() {
  try {
    // 加载维保类型选项
    if (orderType.value != null && orderType.value == '2') {
      // 根据风机型号获取维保类型选项
      const fanType = reEvaluationForm.value.model; // 使用风机型号
      
      if (fanType != null && fanType != '') {
        const response: any = await listInspectionTypesByFanType(fanType as string);
        const resultObj = response as UTSJSONObject;
        const code = resultObj.get('code') as number;
        
        if (code == 200) {
          const data = resultObj.get('data') as UTSJSONObject[];
          
          if (data != null && Array.isArray(data)) {
            inspectionTypeOptions.value = data;
          }
        } else {
          console.error('API返回错误码:', code);
          console.error('错误信息:', resultObj.get('msg'));
        }
      } else {
        console.warn('风机型号为空，无法加载维保类型选项');
      }
    }
  } catch (e: any) {
    console.error('获取维保类型选项失败:', e.message);
  }
}

// 加载工单详情
async function loadOrderDetail() {
  try {
    uni.showLoading({
      title: '加载中...'
    })
    
    const response: any = await getOrderScoreDetail(orderType.value, id.value)
    const resultObj = response as UTSJSONObject
    const code = resultObj.get('code') as number
    
    if (code == 200) {
      const data = resultObj.get('data') as UTSJSONObject
      
      // 设置表单数据
      const formData: ReEvaluationFormData = {
        orderType: orderType.value,
        id: (data.get('id') as number | null) ?? 0,
        workOrderProjectNo: (data.get('workOrderProjectNo') as string | null) ?? '',
        pcsDeviceName: (data.get('pcsDeviceName') as string | null) ?? '',
        pcsStationName: (data.get('pcsStationName') as string | null) ?? '',
        workSummary: orderType.value == '1' ? ((data.get('content') as string | null) ?? '') : ((data.get('realContent') as string | null) ?? ''),
        extraWork: orderType.value == '1' ? ((data.get('extraWork') as string | null) ?? '') : '',
        maintenanceType: (data.get('maintenanceType') as string | null),
        model: (data.get('model') as string | null),  // 风机型号
        inspectionType: orderType.value == '2' ? 
          (Array.isArray(data.get('inspectionType')) ? 
            data.get('inspectionType') as string[] : 
            (((data.get('inspectionType') as string | null)?.split(',') ?? []) as string[])) : [],
        itemCompletionFactor: (data.get('itemCompletionFactor') as number | null) ?? 1.0,
        itemCompletionFactorSum: (data.get('itemCompletionFactorSum') as number | null) ?? 1.0,
        scorePersonList: orderType.value == '1' ? 
          ((data.get('repairOrderPersonList') as UTSJSONObject[] | null) ?? []) : 
          ((data.get('workOrderPersonList') as UTSJSONObject[] | null) ?? []),
        wwryNum: (data.get('wwryNum') as number | null) ?? 0,
        wlryNum: (data.get('wlryNum') as number | null) ?? 0,
        reviewScoreNum: (data.get('reviewScoreNum') as number | null) ?? 0,
        scoreReturnReason: '', // 初始化为空
        modifyReason: '',      // 初始化为空
        feedbackReason: orderType.value == '2' ? ((data.get('feedbackReason') as string | null) ?? '') : '', // 维保工单反馈理由
        initialMaintenanceType: (data.get('maintenanceType') as string | null), // 初始检修类型
        initialItemCompletionFactor: (data.get('itemCompletionFactor') as number | null) ?? 1.0 // 初始分项完成系数
      }
      reEvaluationForm.value = formData
      
      // 为人员列表设置初始分数
      const list = (formData.scorePersonList as UTSJSONObject[])
      for (let i = 0; i < list.length; i++) {
        const person = list[i]
        // 如果复评得分为空，则使用自评得分作为默认值
        const reviewScore = person.get('reviewScore');
        if(reviewScore == null || reviewScore == '') {
          // 使用自评得分作为默认值
          const selfScore = person.get('selfScore');
          if(selfScore != null && selfScore != '') {
            // 正确处理数值类型
            if (typeof selfScore == 'number') {
              person.set('selfScore', parseFloat(selfScore.toString()).toFixed(2));
              person.set('reviewScore', parseFloat(selfScore.toString()).toFixed(2));
            } else {
              person.set('reviewScore', parseFloat(selfScore as string).toFixed(2));
            }
          } else {
            person.set('reviewScore', null);
          }
        } else {
          // 如果复评得分已有值，则格式化为两位小数
          if (typeof reviewScore == 'number') {
            person.set('reviewScore', parseFloat(reviewScore.toString()).toFixed(2));
          } else {
            person.set('reviewScore', parseFloat(reviewScore as string).toFixed(2));
          }
        }

        // 如果有额外工分，则计算总分 = 复评得分 + 额外工分
        // 注意：复评阶段额外工分为只读，不应当修改
        const extraScore = person.get('extraScore');
        const personReviewScore = person.get('reviewScore');
        if (extraScore != null && extraScore != '' && personReviewScore != null && personReviewScore != ''){
          // 正确处理数值类型
          let extraScoreNum = 0;
          if (typeof extraScore == 'number') {
            extraScoreNum = extraScore as number;
          } else {
            extraScoreNum = parseFloat(extraScore as string);
          }
          
          let reviewScoreNum = 0;
          if (typeof personReviewScore == 'number') {
            reviewScoreNum = personReviewScore as number;
          } else {
            reviewScoreNum = parseFloat(personReviewScore as string);
          }
          
          const totalScore = (reviewScoreNum + extraScoreNum).toFixed(2);
          person.set('totalScore', totalScore);
          person.set('extraScore', extraScoreNum.toFixed(2));
        }else if(personReviewScore != null && personReviewScore != ''){
          let reviewScoreNum = 0;
          if (typeof personReviewScore == 'number') {
            reviewScoreNum = personReviewScore as number;
          } else {
            reviewScoreNum = parseFloat(personReviewScore as string);
          }
          //person.set('totalScore', reviewScoreNum);
          person.set('totalScore', reviewScoreNum.toFixed(2));
        } else {
          person.set('totalScore', null);
        }
      }
      
      // 加载检修类型选项
      if (orderType.value != null && orderType.value == '1') {
        await loadMaintenanceTypes()
      }
      
      // 加载维保类型选项
      if (orderType.value != null && orderType.value == '2') {
        await loadInspectionTypeOptions()
      }
      
      // 计算初始分数
      //calculateScores()
      
      // 设置额外工作总结状态标志
      hasExtraWorkFlag.value = formData.extraWork != null && !isWhitespaceOnly(formData.extraWork as string);
      
      // 根据工单类型和数据设置显示控制
      // 如果工单有反馈理由，则显示反馈理由区域
     showFeedbackReason.value = formData.feedbackReason != null && !isWhitespaceOnly(formData.feedbackReason as string);

      // 检查是否存在复评分数与自评分数不同的情况
      hasDifferentReviewAndSelfScore.value = checkDifferentReviewAndSelfScore();
      
      // 如果存在复评分数与自评分数不同，或者工单的初始值与当前值不同，显示修改理由区域
      // 只有两个条件都不存在时才隐藏修改理由
      if (hasDifferentReviewAndSelfScore.value ||
          (orderType.value == '1' && reEvaluationForm.value.maintenanceType != reEvaluationForm.value.initialMaintenanceType) ||
          (orderType.value == '2' && reEvaluationForm.value.itemCompletionFactor != reEvaluationForm.value.initialItemCompletionFactor)) {
        showModifyReason.value = true;
      } else {
        showModifyReason.value = false;
      }
      
      // 如果工单已经有退回理由（来自后端），则显示退回理由区域
      showReturnReason.value = formData.scoreReturnReason != null && !isWhitespaceOnly(formData.scoreReturnReason as string);

      // 初始化已复评总分
      updateReEvaluatedTotalScore()
    } else {
      const msg = resultObj.get('msg') as string | null
      uni.showToast({
        title: msg ?? '加载失败',
        icon: 'none'
      })
    }
  } catch (error: any) {
    console.error('加载工单详情失败:', error)
    uni.showToast({
      title: '加载失败',
      icon: 'none'
    })
  } finally {
    uni.hideLoading()
  }
}

// 加载字典数据
async function loadDictData() {
  try {
    // 加载维保类型字典
    if (orderType.value != null && orderType.value == '2') {
      const result = await getDictDataByType('gxt_inspection_type')
      const resultObj = result as UTSJSONObject

      if (resultObj.get('code') == 200) {
        const data = resultObj.get('data') as any[]
        const dictData: SysDictData[] = []

        if (data != null && data.length > 0) {
          for (let i = 0; i < data.length; i++) {
            const item = data[i] as UTSJSONObject
            // 只提取需要的字段
            const dictItem: SysDictData = {
              dictValue: item.get('dictValue') as string | null,
              dictLabel: item.get('dictLabel') as string | null,
              dictCode: null,
              dictSort: null,
              dictType: null,
              cssClass: null,
              listClass: null,
              isDefault: null,
              status: null,
              default: null,
              createTime: null,
              remark: null
            }
            dictData.push(dictItem)
          }
        }

        inspectionTypeDictList.value = dictData
      }
    }
  } catch (e: any) {
    console.error('获取维保类型字典失败:', e.message)
  }
}

// 退回理由输入处理
function onReturnReasonInput(e: UniInputEvent) {
  const value = e.detail?.value as string
  reEvaluationForm.value.scoreReturnReason = value
  
  // 当用户输入退回理由时，自动显示退回理由区域
  showReturnReason.value = value != null && !isWhitespaceOnly(value as string);
}

// 修改理由输入处理
function onModifyReasonInput(e: UniInputEvent) {
  let value = e.detail?.value as string
  // 限制输入长度在200以内
  if (value != null && value.length > 200) {
    value = value.substring(0, 200)
  }
  reEvaluationForm.value.modifyReason = value
  
  // 当用户输入修改理由时，更新显示控制
  showModifyReason.value = value != null && !isWhitespaceOnly(value as string);
}

// 格式化分项完成系数输入值
function formatItemCompletionFactor() {
  const tempValue = tempItemCompletionFactorInput.value;
  let finalValue: number | null = null;  // 明确定义类型
  
  if (tempValue.endsWith('.')) {
    // 如果以点结尾，去除点号
    const processedValue = tempValue.slice(0, -1);
    
    if (processedValue != '') {
      const numValue = parseFloat(processedValue);
      
      if (!isNaN(numValue) && isFinite(numValue)) {
        if (numValue >= 0 && numValue <= 1) {
          finalValue = numValue;
        } else {
          finalValue = numValue > 1 ? 1 : 0; // 根据数值大小决定边界值
        }
      } else {
        finalValue = 1; // 默认值
      }
    } else {
      // 去掉点后为空，设为null
      finalValue = null;
    }
  } else {
    // 正常数值处理
    const currentValue = reEvaluationForm.value.itemCompletionFactor;
    if (currentValue != null && typeof currentValue == 'number') {
      // 格式化小数位数
      const currentStr = currentValue.toString();
      const parts = currentStr.split('.');
      if (parts.length > 1 && parts[1] != null && parts[1].length > 2) {
        // 创建一个局部变量确保类型安全
        const valueToFormat: number = currentValue;
        finalValue = parseFloat(valueToFormat.toFixed(2));
      } else {
        finalValue = currentValue;
      }
    }
  }
  
  // 更新数值
  reEvaluationForm.value.itemCompletionFactor = finalValue;
  
  // 同步更新临时输入值为格式化后的字符串显示
  if (finalValue != null) {
    tempItemCompletionFactorInput.value = finalValue.toString();
  } else {
    tempItemCompletionFactorInput.value = '';
  }
  
  // 检查是否存在复评分数与自评分数不同的情况
  hasDifferentReviewAndSelfScore.value = checkDifferentReviewAndSelfScore();
  
  // 如果存在复评分数与自评分数不同，或者修改了分项完成系数，显示修改理由
  // 只有两个条件都不存在时才隐藏修改理由
  if (hasDifferentReviewAndSelfScore.value || 
      (reEvaluationForm.value.orderType == '2' && 
       reEvaluationForm.value.itemCompletionFactor != reEvaluationForm.value.initialItemCompletionFactor)) {
    showModifyReason.value = true;
  } else {
    showModifyReason.value = false;
  }
}

function onItemCompletionFactorInput(e: UniInputEvent) { 
  const value = e.detail?.value as string;

  // 更新临时输入值
  tempItemCompletionFactorInput.value = value;
  
  // 检查输入值是否为空
  if (value == '') {
    reEvaluationForm.value.itemCompletionFactor = null;
  } else {
    // 检查是否为中间输入状态（如 '0.' 等以点结尾的数字）
    if (value.endsWith('.')) {
      // 如果是中间输入状态，不更新数值，保持原有值
      return;
    }
    
    // 验证输入值是否为有效数字
    const numValue = parseFloat(value);
    if (!isNaN(numValue) && isFinite(numValue)) {
      if( numValue >= 0 && numValue <= 1){
        // 在input事件中直接使用解析后的数值
        reEvaluationForm.value.itemCompletionFactor = numValue;
      } else {
        // 当超出范围时，设置实际值为边界值
        reEvaluationForm.value.itemCompletionFactor = numValue > 1 ? 1 : 0;
      } 
      
      // 检查是否存在复评分数与自评分数不同的情况
      hasDifferentReviewAndSelfScore.value = checkDifferentReviewAndSelfScore();
      
      // 如果存在复评分数与自评分数不同，或者修改了分项完成系数，显示修改理由
      // 只有两个条件都不存在时才隐藏修改理由
      if (hasDifferentReviewAndSelfScore.value || 
          (reEvaluationForm.value.orderType == '2' && 
           reEvaluationForm.value.itemCompletionFactor != reEvaluationForm.value.initialItemCompletionFactor)) {
        showModifyReason.value = true;
      } else {
        showModifyReason.value = false;
      } 
      
      // 更新可复评总分显示
      updateReEvaluatedTotalScore();
    }  
  }
}

// 获取分项完成系数显示值
function getItemCompletionFactorDisplayValue(): string {
  // 优先返回临时输入值，确保输入过程中的显示与用户操作一致
  if (tempItemCompletionFactorInput.value != null && tempItemCompletionFactorInput.value != '') {
    return tempItemCompletionFactorInput.value;
  }
  
  // 否则返回格式化后的数值
  const value = reEvaluationForm.value.itemCompletionFactor;
  if (value == null) {
    return '';
  }
  
  if (typeof value == 'number') {
    return value.toString();
  }
  
  return value as string;
}

// 获取人员评分
function getPersonScore(person: UTSJSONObject, field: string): string {
  const value = person.get(field as string)
  if (value == null || value == '') {
    return ''
  }
  // 处理不同类型的数据，将其转换为字符串
  if (typeof value == 'number') { 
    // 对于评分字段，仅在小数位数超过2位时保留两位小数格式
    //return (value as number).toFixed(2);
	//return value.toString();
	if(field == 'totalScore'){
	    return (value as number).toFixed(2);
	}else{
	    return value.toString();
	}
  }
  return value as string
}

// 设置人员评分
function setPersonScore(person: UTSJSONObject, field: string, value: any) {
  // 对于评分字段，统一使用number类型
  if (field == 'reviewScore' || field == 'extraScore' || field == 'totalScore') {
    // 处理不同类型的数据
    let numValue: number;
    if (typeof value == 'number') {
      numValue = value as number;
    } else {
      const stringValue = value as string;
      numValue = parseFloat(stringValue);
    }
    if (!isNaN(numValue)) {
      person.set(field as string, numValue);
    } else {
      person.set(field as string, value);
    }
  } else {
    person.set(field as string, value);
  }
}

// 通用评分输入处理
function onScoreInput(e: UniInputEvent, index: number, field: string) {
  const value = e.detail?.value as string
  
  if (index >= 0 && index < reEvaluationForm.value.scorePersonList.length) {
    const person = reEvaluationForm.value.scorePersonList[index] as UTSJSONObject
    if (person != null) {
      // 统一使用数字类型存储分数，如果输入的是数字格式
      if (field == 'reviewScore' || field == 'extraScore' || field == 'totalScore') {
        // 尝试将输入转换为数字，如果成功则存储为数字类型
        const numValue = parseFloat(value);
        if (!isNaN(numValue) && value != '') {
          // 暂时直接存储数值，不在输入时进行格式化处理
          person.set(field as string, numValue);
        } else {
          person.set(field as string, value);
        }
      } else {
        person.set(field as string, value)
      }
      
      // 实时验证评分
      if (value != '') {
        const validationError = validatePersonScore(value, field)
        if (validationError != null) {  // 修复条件判断
          // 显示验证错误（在实际应用中，这里可以显示在界面上）
          console.warn(`评分验证错误: ${validationError}`)
        }
      }
      
      updateTotalScores()
      updateReEvaluatedTotalScore()
    }
  }
}

// 格式化评分输入值
function formatScoreInput(index: number, field: string) {
  if (index >= 0 && index < reEvaluationForm.value.scorePersonList.length) {
    const person = reEvaluationForm.value.scorePersonList[index] as UTSJSONObject
    if (person != null) {
      const value = person.get(field as string);
      if (typeof value == 'number') {
        // 检查数值的小数位数是否超过2位
        const parts = value.toString().split('.');
        if (parts.length > 1) {  // 确保有小数部分
          const decimalPart = parts[1];
          if (decimalPart != null && decimalPart.length > 2) {
            // 如果小数位数超过2位，使用格式化后的值
            const formattedValue = parseFloat((value as number).toFixed(2));
            person.set(field as string, formattedValue);
          }
        }
      }
    }
  }
}

// 分数变化
function onScoreChange() {
  updateTotalScores()
  updateReEvaluatedTotalScore() // 更新已复评总分显示
  
  // 检查是否需要显示修改理由
  // 检查是否存在复评分数与自评分数不同的情况
  hasDifferentReviewAndSelfScore.value = checkDifferentReviewAndSelfScore();
  
  // 如果存在复评分数与自评分数不同，或者修改了分项完成系数，显示修改理由
  // 只有两个条件都不存在时才隐藏修改理由
  if (hasDifferentReviewAndSelfScore.value || 
      (reEvaluationForm.value.orderType == '2' && 
       reEvaluationForm.value.itemCompletionFactor != reEvaluationForm.value.initialItemCompletionFactor)) {
    showModifyReason.value = true;
  } else {
    showModifyReason.value = false;
  }
}

// 返回按钮事件
function goBack() {
  uni.navigateBack()
}

// 提交退回
async function submitReturn(): Promise<void> {
  try {
    // 验证退回理由
    if (reEvaluationForm.value.scoreReturnReason == null || isWhitespaceOnly(reEvaluationForm.value.scoreReturnReason as string)) {
      uni.showToast({
        title: '请输入退回理由',
        icon: 'none'
      });
      return;
    }
    
    uni.showLoading({
      title: '提交中...'
    })
    
    // 创建新的UTSJSONObject来存储表单数据
    const formValue = new UTSJSONObject();
    
    // 复制基本字段
    formValue.set('id', reEvaluationForm.value.id);
    formValue.set('orderType', reEvaluationForm.value.orderType);
    formValue.set('workOrderProjectNo', reEvaluationForm.value.workOrderProjectNo);
    formValue.set('pcsDeviceName', reEvaluationForm.value.pcsDeviceName);
    formValue.set('pcsStationName', reEvaluationForm.value.pcsStationName);
    formValue.set('scoreReturnReason', reEvaluationForm.value.scoreReturnReason); // 退回理由
    formValue.set('maintenanceType', reEvaluationForm.value.maintenanceType);
    formValue.set('itemCompletionFactor', reEvaluationForm.value.itemCompletionFactor);
    formValue.set('itemCompletionFactorSum', reEvaluationForm.value.itemCompletionFactorSum);
    formValue.set('wwryNum', reEvaluationForm.value.wwryNum);
    formValue.set('wlryNum', reEvaluationForm.value.wlryNum);
    formValue.set('reviewScoreNum', reEvaluationForm.value.reviewScoreNum); // 退回时不增加复评次数
    
    // 处理inspectionType字段：如果是数组则转换为字符串
    if (Array.isArray(reEvaluationForm.value.inspectionType)) {
      const strValue = (reEvaluationForm.value.inspectionType as string[]).join(',');
      formValue.set('inspectionType', strValue);
    } else {
      formValue.set('inspectionType', reEvaluationForm.value.inspectionType);
    }
    
    // 复制scorePersonList数组
    const scorePersonListArray: UTSJSONObject[] = [];
    for (let i = 0; i < reEvaluationForm.value.scorePersonList.length; i++) {
      const person = reEvaluationForm.value.scorePersonList[i];
      // 将UTSJSONObject添加到数组中
      scorePersonListArray.push(person);
    } 
    formValue.set('scorePersonList', scorePersonListArray);
    
    // 标记为退回操作
    formValue.set('isReturnOperation', true);
    
    const response: any = await submitReEvaluation(formValue);
  
    const resultObj = response as UTSJSONObject
    const code = resultObj.get('code' as string) as number 
    
    if (code == 200) {
      uni.showToast({
        title: '工单已退回',
        icon: 'success'
      })
      
      // 设置标记，通知上一个页面需要刷新数据
      uni.setStorageSync('needRefresh', true)
      
      // 延迟返回上一页
      setTimeout(() => {
        uni.navigateBack()
      }, 1000)
    } else {
      const msg = resultObj.get('msg' as string) as string | null
      uni.showToast({
        title: msg ?? '退回失败',
        icon: 'none'
      })
    } 
  } catch (error: any) { 
    console.error('提交退回失败:', error)  
    uni.showToast({
      title: '提交失败',
      icon: 'none'
    })
  } finally {
    uni.hideLoading()
  }
}

// 提交复评
async function submitReEvaluationForm(): Promise<void> {
  try {
    // 使用完整的表单验证
    const validation = validateForm() as UTSJSONObject;
    const isValid = validation.get('valid') as boolean;
    const validationMsg = validation.get('message') as string;
    console.log('验证结果:', isValid, '消息:', validationMsg);
    if (!isValid) { 
      console.log('验证失败，显示错误:', validationMsg);

      // 在iOS平台中，有时需要稍作延迟才能正确显示toast
        setTimeout(() => {
          uni.showToast({
            title: validationMsg,
            icon: 'none'
          });
        }, 50);
      return;
    }
    
    uni.showLoading({
      title: '提交中...'
    })
    
    // 创建新的UTSJSONObject来存储表单数据
    const formValue = new UTSJSONObject();
    
    // 复制基本字段
    formValue.set('id', reEvaluationForm.value.id);
    formValue.set('orderType', reEvaluationForm.value.orderType);
    formValue.set('workOrderProjectNo', reEvaluationForm.value.workOrderProjectNo);
    formValue.set('pcsDeviceName', reEvaluationForm.value.pcsDeviceName);
    formValue.set('pcsStationName', reEvaluationForm.value.pcsStationName);
    formValue.set('scoreReturnReason', reEvaluationForm.value.scoreReturnReason); // 退回理由
    formValue.set('maintenanceType', reEvaluationForm.value.maintenanceType);
    formValue.set('itemCompletionFactor', reEvaluationForm.value.itemCompletionFactor);
    formValue.set('itemCompletionFactorSum', reEvaluationForm.value.itemCompletionFactorSum);
    //formValue.set('modifyReason', reEvaluationForm.value.modifyReason); // 修改理由
    formValue.set('wwryNum', reEvaluationForm.value.wwryNum);
    formValue.set('wlryNum', reEvaluationForm.value.wlryNum);
    formValue.set('reviewScoreNum', reEvaluationForm.value.reviewScoreNum + 1); // 增加复评次数
    
    // 处理inspectionType字段：如果是数组则转换为字符串
    if (Array.isArray(reEvaluationForm.value.inspectionType)) {
      const strValue = (reEvaluationForm.value.inspectionType as string[]).join(',');
      formValue.set('inspectionType', strValue);
    } else {
      formValue.set('inspectionType', reEvaluationForm.value.inspectionType);
    }
    
    // 复制scorePersonList数组
    const scorePersonListArray: UTSJSONObject[] = [];
    for (let i = 0; i < reEvaluationForm.value.scorePersonList.length; i++) {
      const person = reEvaluationForm.value.scorePersonList[i];
      // 将UTSJSONObject添加到数组中
      scorePersonListArray.push(person);
    } 
    formValue.set('scorePersonList', scorePersonListArray);
    
    // 标记为正常复评操作
    formValue.set('isReturnOperation', false);
	
	if(showModifyReason.value == false){
		formValue.set('modifyReason', '');
	}else{
		formValue.set('modifyReason', reEvaluationForm.value.modifyReason);
	}
    
    const response: any = await submitReEvaluation(formValue);
  
    const resultObj = response as UTSJSONObject
    const code = resultObj.get('code' as string) as number 
    
    if (code == 200) {
      uni.showToast({
        title: '复评提交成功',
        icon: 'success'
      })
      
      // 设置标记，通知上一个页面需要刷新数据
      uni.setStorageSync('needRefresh', true)
      
      // 延迟返回上一页
      setTimeout(() => {
        uni.navigateBack()
      }, 1000)
    } else {
      const msg = resultObj.get('msg' as string) as string | null
      uni.showToast({
        title: msg ?? '提交失败',
        icon: 'none'
      })
    } 
  } catch (error: any) { 
    console.error('提交复评失败:', error)  
    let msg: string | null = null
    if (error instanceof Error) {
      msg = error.message
    } else if (error instanceof UTSJSONObject && error.get('message') != null) {
      msg = error.get('message') as string | null
    }
    uni.showToast({
      title: msg ?? '提交失败',
      icon: 'none'
    })
  } finally {
    uni.hideLoading()
  }
}

  // 页面初始化
  onLoad((options: any) => {
    const params = options as UTSJSONObject
    id.value = (params.get('id') != null ? params.get('id') as string : '')
    orderType.value = (params.get('orderType') != null ? params.get('orderType') as string : '')

    // 加载字典数据
    loadDictData()
    // 加载工单详情
    loadOrderDetail()
  })
 
</script>

<style lang="scss">
.container {
  flex: 1;
  background-color: #e8f0f9;
  padding-bottom: 130rpx;
  //height: 100vh;
}

.header {
  padding: 30rpx;
  text-align: center;
}

.title {
  font-size: 36rpx;
  font-weight: bold;
  color: #333;
}

.form {
  padding: 0 30rpx 30rpx;
}

.info-card {
  background-color: #ffffff;
  border-radius: 16rpx;
  padding: 30rpx;
  margin-bottom: 20rpx;
}

.info-item {
  flex-direction: row;
  padding: 20rpx 0;
  border-bottom: 1rpx solid #f0f0f0;

  &:last-child {
    border-bottom: none;
  }

  .info-label {
    width: 240rpx;
    font-size: 28rpx;
    color: #666666;
    white-space: nowrap;
  }

  .info-value {
    flex: 1;
    font-size: 28rpx;
    color: #333333;
    text-align: right;
  }
  
  .info-input {
    flex: 1;
    font-size: 28rpx;
    color: #333333;
    border: 1rpx solid #e0e0e0;
    border-radius: 8rpx;
    padding: 10rpx;
	text-align: right;
  }
}

.info-item-row {
  display: flex;
  flex-direction: row;
  width: 100%;
}

.info-item-half {
  flex: 1;
  flex-direction: row;
  padding: 20rpx 0;
  border-bottom: 1rpx solid #f0f0f0;

  &:first-child {
    margin-right: 20rpx;
  }

  .info-label {
    width: 180rpx;
    font-size: 28rpx;
    color: #666666;
    white-space: nowrap;
  }

  .info-value {
    flex: 1;
    font-size: 28rpx;
    color: #333333;
    text-align: right;
  }
}

.form-item {
  margin-bottom: 30rpx;
  display: flex;
  flex-direction: column;
}

.label {
  font-size: 28rpx;
  color: #666;
  margin-bottom: 10rpx;
  font-weight: bold;
}

.value {
  font-size: 28rpx;
  color: #333;
}

.textarea {
  width: 100%;
  height: 200rpx;
  border: 1rpx solid #e5e5e5;
  border-radius: 8rpx;
  padding: 20rpx;
  font-size: 28rpx;
  color: #333;
}

.picker {
  width: 100%;
}

.picker-display {
  flex-direction: row;
  justify-content: space-between;
  align-items: center;
  padding: 10rpx;
  border: 1rpx solid #e5e5e5;
  border-radius: 8rpx;
}

.selected-value {
  font-size: 28rpx;
  color: #333;
}

.placeholder {
  font-size: 28rpx;
  color: #999;
}

.arrow {
  font-size: 24rpx;
  color: #999;
}

.selected-values {
  display: flex;
  flex-wrap: wrap;
  //gap: 10rpx;
}

.selected-value-tag {
  background-color: #f0f0f0;
  padding: 8rpx 16rpx;
  border-radius: 20rpx;
  font-size: 24rpx;
  color: #666;
}

.person-score-item {
  margin-bottom: 30rpx;
  padding: 20rpx;
  background-color: #f8f9fa;
  border-radius: 12rpx;
}

.person-info {
  margin-bottom: 15rpx;
}

.person-name {
  font-size: 28rpx;
  font-weight: bold;
  color: #333;
}

.score-inputs {
  display: flex;
  flex-direction: column;
  //gap: 15rpx;
}

.score-item {
  display: flex;
  flex-direction: row;
  align-items: center;
  justify-content: space-between;
  padding: 8rpx 0;
}

.score-label {
  font-size: 26rpx;
  color: #666;
  width: 120rpx;
  flex-shrink: 0;
}

.score-input {
  flex: 1;
  height: 60rpx;
  border: 1rpx solid #e0e0e0;
  border-radius: 8rpx;
  padding: 0 15rpx;
  font-size: 26rpx;
  color: #333;
  text-align: right;
}

.score-value {
  flex: 1;
  height: 60rpx;
  border: 1rpx solid #e0e0e0;
  border-radius: 8rpx;
  padding: 15rpx 15rpx;
  font-size: 26rpx;
  color: #333;
  text-align: right;
  background-color: #f5f5f5;
}

.warning-btn {
  height: 80rpx;
  background-color: #faad14; // warning color
  border-radius: 10rpx;
  display: flex;
  align-items: center;
  justify-content: center;
}

.submit-btn {
  height: 80rpx;
  background-color: #165DFF;
  border-radius: 10rpx;
  display: flex;
  align-items: center;
  justify-content: center;
}

.button-group {
  position: fixed;
  bottom: 0;
  left: 0;
  right: 0;
  padding: 30rpx;
  background-color: #ffffff;
  box-shadow: 0 -2rpx 10rpx rgba(0, 0, 0, 0.1);
  z-index: 100;
  display: flex;
  gap: 20rpx;
}

.btn-text {
  font-size: 32rpx;
  color: #fff;
  font-weight: bold;
}

.submit-text {
  font-size: 32rpx;
  color: #fff;
  font-weight: bold;
}

/* 自定义选择器样式 */
.picker-modal {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    z-index: 1000;
}

.modal-mask {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background-color: rgba(0, 0, 0, 0.5);
}

.modal-content {
    position: absolute;
    bottom: 0;
    left: 0;
    right: 0;
    background-color: #ffffff;
    border-top-left-radius: 16rpx;
    border-top-right-radius: 16rpx;
    min-height: 700rpx;
}

.modal-header {
    flex-direction: row;
    justify-content: space-between;
    align-items: center;
    padding: 30rpx;
    border-bottom: 1rpx solid #f0f0f0;
}

.modal-title {
    font-size: 32rpx;
    font-weight: bold;
    color: #333333;
}

.modal-close {
    font-size: 28rpx;
    color: #165DFF;
}

.modal-body {
    max-height: 600rpx;
}

.picker-option {
    flex-direction: row;
    justify-content: space-between;
    align-items: center;
    padding: 24rpx 30rpx;
    border-bottom: 1rpx solid #f0f0f0;
}

.picker-option.selected {
    background-color: #f8f9fa;
}

.option-text {
    font-size: 28rpx;
    color: #333333;
}

.option-check {
    font-size: 28rpx;
    color: #165DFF;
}

.form-picker {
    flex: 1;
}

.picker-display {
    flex-direction: row;
    justify-content: space-between;
    align-items: center;
    min-height: 40rpx;
}

.selected-value {
    font-size: 28rpx;
    color: #333333;
}

.placeholder {
    font-size: 28rpx;
    color: #999999;
}

.arrow {
    font-size: 24rpx;
    color: #999999;
    margin-left: 12rpx;
}
/* 人员评分项目样式 */
.person-score-item {
  border: 1rpx solid #e0e0e0;
  border-radius: 8rpx;
  padding: 15rpx;
  margin-bottom: 15rpx;
  background-color: #fafafa;
}

.person-info {
  margin-bottom: 10rpx;
}

.person-name {
  font-size: 28rpx;
  font-weight: bold;
  color: #333;
}
</style>