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 { useUserStore} from '@/store/userStore'

const createDefaultFormData = () => ({
  event: {
  },
  report: {
  },
  lossList: [],
  fileList: []
})

export const useWaterDisasterReport = () => {
  const router = useRouter()
  const route = useRoute()
  const userStore = useUserStore()
  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 = {
    // 'report.contactPerson': [{ required: true, message: '请输入联系人员', trigger: 'blur' }],
    'report.contactPhone': [
      // { required: true, message: '请输入联系电话', trigger: 'blur' },
      { pattern: /^1[3-9]\d{9}$/, message: '请输入正确的联系电话', trigger: 'blur' }
    ],
    'event.serviceStationId': [{ required: true, message: '请选择填报站点', trigger: 'change' }],
    "event.occurTime": [{ required: true, message: '请选择发生时间', trigger: 'change' }],
    'event.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' }],
    'event.routeNo': [{ required: true, message: '请选择线路编号', trigger: 'change' }],
    'event.occurLocation': [{ required: true, message: '请选择路况位置', trigger: ['change', 'blur'] }],
    'event.blockedPointName': [{ required: true, message: '请输入阻断点小地名', trigger: 'blur' }],
    'event.startStakeNo': [{ required: true, message: '请输入起点桩号', trigger: 'blur' }],
    'event.startStakeLng': [{ required: true, message: '请输入起点桩经度', trigger: 'blur' }],
    'event.startStakeLat': [{ required: true, message: '请输入起点桩纬度', trigger: 'blur' }],
    'event.endStakeNo': [{ required: true, message: '请输入止点桩号', trigger: 'blur' }],
    'event.endStakeLat': [{ 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 = {}) => {
    formData.event.reporterUnit = userStore.userInfo?.organization?.orgName
  }

  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.startStakeLng = startPoint.longitude
    formData.event.startStakeLat = startPoint.latitude
    formData.event.endStakeLng = endPoint.longitude
    formData.event.endStakeLat = endPoint.latitude
  }

  const buildSubmitData = () => {
    return formData
  }

  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/report',
        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({})
  })

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