/**
 * 警情操作逻辑 Mixin
 * 包含：创建、更新、提交、关闭等操作
 */
import { addAlert, updateAlert, submitAlert, closeAlert } from '@/api/duty/alert'
import { formatDateTime } from '../utils/dateHelpers'

export default {
  methods: {
    /**
     * 映射前端来源渠道代码到后端枚举代码
     */
    mapSourceChannelToBackend(frontendCode) {
      const channelMap = {
        'phone_122': '122',
        'phone_12345': '12345',
        'phone_110': '110',
        'transfer': 'superior', // 默认映射为上级转办
        'monitoring': 'monitor',
        'media': 'media',
        'other': 'manual'
      }
      return channelMap[frontendCode] || frontendCode
    },
    
    /**
     * 构建警情数据对象
     */
    buildAlertData(formData, action, longitude = null, latitude = null) {
      // 如果没有选择发生时间，使用当前时间
      let occurredAt = formData.occurredAt
      if (!occurredAt) {
        occurredAt = formatDateTime(new Date())
      }
      
      // 构建请求数据
      const alertData = {
        summary: formData.summary || '',
        sourceChannel: formData.sourceChannel ? this.mapSourceChannelToBackend(formData.sourceChannel) : null,
        callerNumber: formData.callerNumber || '',
        initialLevel: formData.initialLevel,
        occurredAt: occurredAt,
        location: formData.location || '',
        remark: formData.remark || '',
        status: action === '草稿' ? 'draft' : 'received'
      }
      
      // 添加经纬度（如果已选择位置）
      if (longitude !== null && latitude !== null) {
        alertData.longitude = longitude
        alertData.latitude = latitude
      }
      
      // 处理来源扩展信息（序列化为 JSON 字符串）
      if (formData.sourceExtInfo && Object.keys(formData.sourceExtInfo).length > 0) {
        // 过滤掉空值
        const extInfo = {}
        for (const key in formData.sourceExtInfo) {
          if (formData.sourceExtInfo[key] !== null && formData.sourceExtInfo[key] !== undefined && formData.sourceExtInfo[key] !== '') {
            extInfo[key] = formData.sourceExtInfo[key]
          }
        }
        // 如果有有效数据，序列化为 JSON 字符串
        if (Object.keys(extInfo).length > 0) {
          alertData.sourceExtInfo = JSON.stringify(extInfo)
        }
      }
      
      return alertData
    },
    
    /**
     * 验证电话渠道的来电号码
     */
    validatePhoneChannel(formData, action) {
      if (['phone_122', 'phone_12345', 'phone_110'].includes(formData.sourceChannel)) {
        if (!formData.callerNumber && action === '提交') {
          this.$message.error('电话渠道需要填写来电号码')
          return false
        }
      }
      return true
    },
    
    /**
     * 处理警情操作（创建/更新/提交/保存草稿）
     */
    async handleAlertAction(action, formData, editingAlertId, longitude = null, latitude = null) {
      // 防止重复提交
      if (this.submitting) {
        this.$message.warning('正在处理中，请稍候...')
        return { success: false }
      }
      
      // 对于提交操作，需要先验证表单
      if (action === '提交') {
        try {
          // 修复：使用弹窗中的表单引用
          const formRef = this.$refs.alertFormDialog?.$refs?.alertForm || null
          if (formRef) {
            await formRef.validate()
          } else {
            this.$message.error('表单引用不存在，请重试')
            return { success: false }
          }
        } catch (error) {
          this.$message.error('请先填写必要信息')
          return { success: false }
        }
      }
      
      // 验证电话渠道
      if (!this.validatePhoneChannel(formData, action)) {
        return { success: false }
      }
      
      this.submitting = true
      
      try {
        // 构建请求数据
        const alertData = this.buildAlertData(formData, action, longitude, latitude)
        
        // 调用后端API
        let response
        if (editingAlertId) {
          // 编辑模式
          if (action === '提交') {
            // 提交操作：使用submit端点，同时更新数据和状态（仅限草稿状态）
            response = await submitAlert(editingAlertId, alertData)
          } else if (action === '更新') {
            // 更新已提交的警情：只更新数据，不改变状态
            alertData.id = editingAlertId
            // 不设置status字段，保持当前状态
            delete alertData.status
            response = await updateAlert(alertData)
          } else {
            // 保存草稿：直接更新（仅限草稿状态）
            alertData.id = editingAlertId
            response = await updateAlert(alertData)
          }
        } else {
          // 新建模式
          response = await addAlert(alertData)
        }
        
        if (response.code === 200) {
          const successMsg = editingAlertId
            ? (action === '草稿' ? '草稿更新成功' : action === '更新' ? '警情更新成功' : '警情提交成功')
            : (action === '草稿' ? '草稿保存成功' : '警情提交成功')
          
          this.$message.success(successMsg)
          
          return {
            success: true,
            data: response.data,
            message: successMsg
          }
        } else {
          this.$message.error(response.msg || '操作失败')
          return { success: false, error: response.msg }
        }
      } catch (error) {
        console.error('保存警情失败:', error)
        this.$message.error(error.msg || error.message || '操作失败，请稍后重试')
        return { success: false, error: error.message }
      } finally {
        this.submitting = false
      }
    },
    
    /**
     * 提交草稿警情（从抽屉调用）
     */
    async submitDraftAlert(alertId) {
      if (!alertId) {
        return { success: false, error: '警情ID不能为空' }
      }
      
      try {
        // Submit without updating data (just change status from draft to received)
        const response = await submitAlert(alertId, null)
        
        if (response.code === 200) {
          this.$message.success('警情提交成功')
          return {
            success: true,
            data: response.data,
            message: '警情提交成功'
          }
        } else {
          this.$message.error(response.msg || '提交失败')
          return { success: false, error: response.msg }
        }
      } catch (error) {
        console.error('提交警情失败:', error)
        this.$message.error(error.msg || error.message || '提交失败，请稍后重试')
        return { success: false, error: error.message }
      }
    },
    
    /**
     * 关闭警情（从抽屉调用）
     */
    async closeAlertById(alertId) {
      if (!alertId) {
        return { success: false, error: '警情ID不能为空' }
      }
      
      // Confirm before closing
      try {
        await this.$confirm('确定要关闭此警情吗？关闭后状态将变为"已关闭"。', '确认关闭', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning'
        })
      } catch {
        return { success: false, cancelled: true } // User cancelled
      }
      
      try {
        const response = await closeAlert(alertId)
        
        if (response.code === 200) {
          this.$message.success('警情已关闭')
          return {
            success: true,
            data: response.data,
            message: '警情已关闭'
          }
        } else {
          this.$message.error(response.msg || '关闭失败')
          return { success: false, error: response.msg }
        }
      } catch (error) {
        console.error('关闭警情失败:', error)
        this.$message.error(error.msg || error.message || '关闭失败，请稍后重试')
        return { success: false, error: error.message }
      }
    }
  }
}