bxztApp/packages/screen/src/views/DisasterManagement/WaterDisasterReport/useWaterDisasterReport.js

import { computed, onMounted, reactive, ref } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import { ElMessage } from 'element-plus'
import { request } from '@/utils/request'
import { useOptions } from '@shared/composables/useOptions'
import mockData from './waterMockJson.json'

const DEFAULT_REPORTER_UNIT = '万州区公路中心'

const createDefaultFormData = () => ({
  occurLocation: '',
  occurTime: '',
  roadConditionType: '',
  routeNo: '',
  event: {
    blockedMileage: null,
    blockedPointName: '',
    contactPerson: '',
    contactPhone: '',
    damageCount: null,
    district: '',
    endStakeLatitude: null,
    endStakeLongitude: null,
    endStakeNo: '',
    estimatedRecoveryCost: null,
    isBlocked: null,
    latitude: null,
    longitude: null,
    needsRecovery: null,
    repairProgress: '抢险中',
    reportSite: '',
    reporterUnit: DEFAULT_REPORTER_UNIT,
    serviceStationId: '',
    startStakeLatitude: null,
    startStakeLongitude: null,
    startStakeNo: ''
  },
  report: {
    actualRecoverTime: '',
    damagedVehicleCount: null,
    deadCount: null,
    disposalMeasures: '',
    expectRecoverTime: '',
    injuredCount: null,
    investedFunds: null,
    investedMachinery: null,
    investedManpower: null,
    remark: '',
    siteDescription: '',
    strandedPersonCount: null,
    strandedVehicleCount: null,
    totalLossAmount: null
  },
  lossList: [],
  fileList: []
})

const mergeFormData = (source = {}) => {
  const defaults = createDefaultFormData()
  const merged = {
    ...defaults,
    ...source,
    event: {
      ...defaults.event,
      ...(source.event || {})
    },
    report: {
      ...defaults.report,
      ...(source.report || {})
    },
    lossList: Array.isArray(source.lossList) ? source.lossList : defaults.lossList,
    fileList: Array.isArray(source.fileList) ? source.fileList : defaults.fileList
  }

  if (!merged.event.reporterUnit) {
    merged.event.reporterUnit = DEFAULT_REPORTER_UNIT
  }
  if (!merged.event.repairProgress) {
    merged.event.repairProgress = '抢险中'
  }
  if (!merged.event.serviceStationId && merged.event.reportSite) {
    merged.event.serviceStationId = merged.event.reportSite
  }

  return merged
}

export const useWaterDisasterReport = () => {
  const router = useRouter()
  const route = useRoute()
  const { options, getAreaOptions } = useOptions()

  const formRef = ref(null)
  const submitting = ref(false)
  const eventType = ref('水毁事件')
  const filterForm = reactive({
    routeType: ''
  })
  const formData = reactive(createDefaultFormData())

  const routeTypeLabel = computed(() => {
    const matched = options.value.roadType?.find((item) => item.value === filterForm.routeType)
    return matched?.label || '国省道'
  })

  const showEstimatedRecoveryCost = computed(() => formData.event.needsRecovery === true)

  const formRules = {
    'event.contactPerson': [{ required: true, message: '请输入联系人员', trigger: 'blur' }],
    'event.contactPhone': [
      { required: true, message: '请输入联系电话', trigger: 'blur' },
      { pattern: /^1[3-9]\d{9}$/, message: '请输入正确的联系电话', trigger: 'blur' }
    ],
    'event.serviceStationId': [{ required: true, message: '请选择填报站点', trigger: 'change' }],
    occurTime: [{ required: true, message: '请选择发生时间', trigger: 'change' }],
    roadConditionType: [{ required: true, message: '请选择路况类别', trigger: 'change' }],
    'event.repairProgress': [{ required: true, message: '请选择抢险进度', trigger: 'change' }],
    'event.isBlocked': [{ required: true, message: '请选择是否阻断', trigger: 'change' }],
    'event.blockedMileage': [{ required: true, message: '请输入受灾里程', trigger: 'blur' }],
    'event.damageCount': [{ required: true, message: '请输入水毁处数', trigger: 'blur' }],
    'event.district': [{ required: true, message: '请选择所属区县', trigger: 'change' }],
    routeNo: [{ required: true, message: '请选择线路编号', trigger: 'change' }],
    occurLocation: [{ required: true, message: '请输入路况位置', trigger: 'blur' }],
    'event.blockedPointName': [{ required: true, message: '请输入阻断点小地名', trigger: 'blur' }],
    'event.startStakeNo': [{ required: true, message: '请输入起点桩号', trigger: 'blur' }],
    'event.startStakeLongitude': [{ required: true, message: '请输入起点桩经度', trigger: 'blur' }],
    'event.startStakeLatitude': [{ required: true, message: '请输入起点桩纬度', trigger: 'blur' }],
    'event.endStakeNo': [{ required: true, message: '请输入止点桩号', trigger: 'blur' }],
    'event.endStakeLongitude': [{ required: true, message: '请输入止点桩经度', trigger: 'blur' }],
    'event.endStakeLatitude': [{ required: true, message: '请输入止点桩纬度', trigger: 'blur' }],
    'report.disposalMeasures': [{ required: true, message: '请选择处置措施', trigger: 'change' }],
    'report.expectRecoverTime': [{ required: true, message: '请选择预计恢复时间', trigger: 'change' }],
    'event.needsRecovery': [{ required: true, message: '请选择是否需要恢复重建', trigger: 'change' }],
    'event.estimatedRecoveryCost': [
      {
        validator: (_rule, value, callback) => {
          if (showEstimatedRecoveryCost.value && (value === '' || value === null || value === undefined)) {
            callback(new Error('请输入恢复重建预估费用'))
            return
          }
          callback()
        },
        trigger: 'blur'
      }
    ]
  }

  const initFormData = (data = {}) => {
    Object.assign(formData, mergeFormData(data))
  }

  const handleEventTypeChange = (value) => {
    if (value === '冰雪事件') {
      router.replace({ path: '/iceDisasterReport' })
    }
  }

  const handleDistrictChange = () => {
    // formData.routeNo = ''
    // formData.occurLocation = ''
    // formData.event.startStakeNo = ''
    // formData.event.endStakeNo = ''
  }

  const parsePointValue = (point) => {
    if (!point) {
      return { longitude: null, latitude: null }
    }

    if (Array.isArray(point) && point.length >= 2) {
      return {
        longitude: point[0] ?? null,
        latitude: point[1] ?? null
      }
    }

    if (typeof point === 'string') {
      try {
        const parsed = JSON.parse(point)
        if (Array.isArray(parsed) && parsed.length >= 2) {
          return {
            longitude: parsed[0] ?? null,
            latitude: parsed[1] ?? null
          }
        }
      } catch (_error) {
        return { longitude: null, latitude: null }
      }
    }

    return { longitude: null, latitude: null }
  }

  const handleRouteNoChange = (item = {}) => {
    formData.routeNo = item.routeCode 
    formData.event.startStakeNo = item.startStakeNo
    formData.event.endStakeNo = item.endStakeNo

    const startPoint = parsePointValue(item.startPoint)
    const endPoint = parsePointValue(item.endPoint)

    formData.event.startStakeLongitude = startPoint.longitude
    formData.event.startStakeLatitude = startPoint.latitude
    formData.event.endStakeLongitude = endPoint.longitude
    formData.event.endStakeLatitude = endPoint.latitude
  }

  const buildSubmitData = () => {
    const payload = mergeFormData(formData)
    if (!payload.event.reportSite && payload.event.serviceStationId) {
      payload.event.reportSite = payload.event.serviceStationId
    }

    return payload
  }

  const getFormData = () => buildSubmitData()

  const validate = async () => {
    if (!formRef.value) {
      return false
    }

    try {
      await formRef.value.validate()
      return true
    } catch (_error) {
      ElMessage.warning('请完善表单信息')
      return false
    }
  }

  const handleSubmit = async () => {
    if (!(await validate())) {
      return
    }

    submitting.value = true
    try {
      const res = await request({
        url: '/snow-ops-platform/water-damage/addOrUpdate',
        method: 'post',
        data: buildSubmitData()
      })

      if (res?.code === '00000') {
        ElMessage.success('提交成功')
        setTimeout(() => {
          router.replace('/disasterManagement')
        }, 500)
      } else {
        ElMessage.error(res?.message || '提交失败')
      }
    } catch (error) {
      console.error('提交失败:', error)
      ElMessage.error('提交失败，请重试')
    } finally {
      submitting.value = false
    }
  }


  const handleBack = () => {
    router.back()
  }

  onMounted(async () => {
    await getAreaOptions()

    initFormData(route.query.mock ? mockData : {})
  })

  return {
    eventType,
    filterForm,
    formData,
    formRef,
    formRules,
    handleBack,
    handleDistrictChange,
    handleEventTypeChange,
    handleRouteNoChange,
    handleSubmit,
    initFormData,
    getFormData,
    options,
    routeTypeLabel,
    showEstimatedRecoveryCost,
    submitting,
    validate
  }
}