import { ref, computed } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import { showToast, showLoadingToast } from 'vant'
import { qiniuTokenAPI, qiniuUploadAPI, saveFileAPI } from '@/api/common'
import { addUploadTaskAPI, getUploadTaskInfoAPI, editUploadTaskInfoAPI } from "@/api/checkin"
import { qiniuFileHash } from '@/utils/qiniuFileHash';
import { useAuth } from '@/contexts/auth'

/**
 * 打卡功能的composable
 * @returns {Object} 打卡相关的状态和方法
 */
export function useCheckin() {
    const route = useRoute()
    const router = useRouter()
    const { currentUser } = useAuth()

    // 基础状态
    const uploading = ref(false)
    const loading = ref(false)
    const message = ref('')
    const fileList = ref([])
    const activeType = ref('text') // 当前选中的打卡类型
    const maxCount = ref(5)

    // 用于记忆不同类型的文件列表
    const fileListMemory = ref({
        text: [],
        image: [],
        video: [],
        audio: []
    })

    /**
     * 是否可以提交
     */
    const canSubmit = computed(() => {
        if (activeType.value === 'text') {
            // 文字打卡：必须填写内容且长度不少于10个字符
            return message.value.trim() !== '' && message.value.trim().length >= 10
        } else {
            // 图片、视频、音频打卡：必须有文件，内容可选
            return fileList.value.length > 0
        }
    })

    /**
     * 获取文件哈希（与七牛云ETag一致）
     * @param {File} file 文件对象
     * @returns {Promise<string>} 哈希字符串
     * 注释：使用 qiniuFileHash 进行计算，替代浏览器MD5方案。
     */
    const getFileMD5 = async (file) => {
        return await qiniuFileHash(file)
    }

    /**
     * 上传文件到七牛云
     * @param {File} file - 文件对象
     * @param {string} token - 七牛云token
     * @param {string} fileName - 文件名
     * @returns {Promise<Object>} 上传结果
     */
    const uploadToQiniu = async (file, token, fileName) => {
        const formData = new FormData()
        formData.append('file', file)
        formData.append('token', token)
        formData.append('key', fileName)

        const config = {
            headers: { 'Content-Type': 'multipart/form-data' }
        }

        // 根据协议选择上传地址
        const qiniuUploadUrl = window.location.protocol === 'https:'
            ? 'https://up.qbox.me'
            : 'http://upload.qiniu.com'

        return await qiniuUploadAPI(qiniuUploadUrl, formData, config)
    }

    /**
     * 处理单个文件上传
     * @param {Object} file - 文件对象
     * @returns {Promise<Object|null>} 上传结果
     */
    const handleUpload = async (file) => {
        loading.value = true
        try {
            // 获取MD5值
            const md5 = await getFileMD5(file.file)

            // 获取七牛token
            const tokenResult = await qiniuTokenAPI({
                name: file.file.name,
                hash: md5
            })

            // 文件已存在，直接返回
            if (tokenResult.data) {
                return tokenResult.data
            }

            // 新文件上传
            if (tokenResult.token) {
                const suffix = /.[^.]+$/.exec(file.file.name) || ''
                let fileName = ''

                if (activeType.value === 'image') {
                    fileName = `mlaj/upload/checkin/${currentUser.value.mobile}/img/${md5}${suffix}`
                } else {
                    fileName = `mlaj/upload/checkin/${currentUser.value.mobile}/file/${md5}${suffix}`
                }

                const uploadResult = await uploadToQiniu(
                    file.file,
                    tokenResult.token,
                    fileName
                )

                if (uploadResult.filekey) {
                    // 保存文件信息
                    const saveData = {
                        name: file.file.name,
                        filekey: uploadResult.filekey,
                        hash: md5
                    }

                    // 图片类型需要保存尺寸信息
                    if (activeType.value === 'image' && uploadResult.image_info) {
                        saveData.height = uploadResult.image_info.height
                        saveData.width = uploadResult.image_info.width
                    }

                    const { data } = await saveFileAPI(saveData)
                    return data
                }
            }
            return null
        } catch (error) {
            console.error('Upload error:', error)
            return null
        } finally {
            loading.value = false
        }
    }

    /**
     * 文件上传前的校验
     * @param {File|File[]} file - 文件或文件数组
     * @returns {boolean} 是否通过校验
     */
    const beforeRead = (file) => {
        let flag = true
        const files = Array.isArray(file) ? file : [file]

        // 检查文件数量
        if (fileList.value.length + files.length > maxCount.value) {
            flag = false
            showToast(`最大上传数量为${maxCount.value}个`)
            return flag
        }

        // 检查文件类型和大小
        for (const item of files) {
            const fileType = item.type.toLowerCase()

            // 文件大小检查
            if ((item.size / 1024 / 1024).toFixed(2) > 20) {
                flag = false
                showToast('最大文件体积为20MB')
                break
            }

            // 文件类型检查
            if (activeType.value === 'image') {
                const imageTypes = ['jpg', 'jpeg', 'png']
                const validImageTypes = imageTypes.map(type => `image/${type}`)
                if (!validImageTypes.some(type => fileType.includes(type.split('/')[1]))) {
                    flag = false
                    showToast('请上传指定格式图片')
                    break
                }
            } else if (activeType.value === 'video') {
                if (!fileType.startsWith('video/')) {
                    flag = false
                    showToast('请上传视频文件')
                    break
                }
            } else if (activeType.value === 'audio') {
                if (!fileType.startsWith('audio/')) {
                    flag = false
                    showToast('请上传音频文件')
                    break
                }
            }
        }

        return flag
    }

    /**
     * 文件读取后的处理
     * @param {File|File[]} file - 文件或文件数组
     */
    const afterRead = async (file) => {
        const files = Array.isArray(file) ? file : [file]

        for (const item of files) {
            item.status = 'uploading'
            item.message = '上传中...'

            const result = await handleUpload(item)
            if (result) {
                item.status = 'done'
                item.message = '上传成功'
                item.url = result.url
                item.meta_id = result.meta_id
                item.name = result.name || item.file.name
            } else {
                item.status = 'failed'
                item.message = '上传失败'
                showToast('上传失败，请重试')
            }
        }
    }

    /**
     * 删除文件
     * @param {Object} file - 要删除的文件对象
     */
    const onDelete = (file) => {
        const index = fileList.value.findIndex(item => item === file)
        if (index > -1) {
            fileList.value.splice(index, 1)
        }
    }

    /**
     * 删除文件项
     * @param {Object} item - 要删除的文件项
     */
    const delItem = (item) => {
        const index = fileList.value.findIndex(file => file === item)
        if (index > -1) {
            fileList.value.splice(index, 1)
        }
    }

    /**
     * 提交打卡
     */
    const onSubmit = async () => {
        if (uploading.value) return

        // 表单验证
        if (activeType.value === 'text') {
            if (message.value.trim().length < 10) {
                showToast('打卡内容至少需要10个字符')
                return
            }
        } else {
            if (fileList.value.length === 0) {
                showToast('请先上传文件')
                return
            }
            // if (message.value.trim() === '') {
            //     showToast('请输入打卡留言')
            //     return
            // }
        }

        uploading.value = true
        showLoadingToast({
            message: '提交中...',
            forbidClick: true,
        })

        try {
            // 准备提交数据
            const submitData = {
                task_id: route.query.id,
                note: message.value,
                file_type: activeType.value,
                meta_id: [],
                makeup_time: route.query.is_patch ? route.query.date : '',
            }

            // 如果有文件，添加文件ID
            if (fileList.value.length > 0) {
                submitData.meta_id = fileList.value
                    .filter(item => item.status === 'done' && item.meta_id)
                    .map(item => item.meta_id)
            }

            let result
            if (route.query.status === 'edit') {
                // 编辑打卡
                result = await editUploadTaskInfoAPI({
                    i: route.query.post_id,
                    note: submitData.note,
                    meta_id: submitData.meta_id,
                    file_type: submitData.file_type,
                })
            } else {
                // 新增打卡
                result = await addUploadTaskAPI(submitData)
            }

            if (result.code) {
                showToast('提交成功')
                router.back()
            }
        } catch (error) {
            showToast('提交失败，请重试')
        } finally {
            uploading.value = false
        }
    }

    /**
     * 切换打卡类型
     * @param {string} type - 打卡类型
     */
    const switchType = (type) => {
        if (activeType.value !== type) {
            // 保存当前类型的文件列表到记忆中
            fileListMemory.value[activeType.value] = [...fileList.value]

            // 切换到新类型
            activeType.value = type

            // 恢复新类型的文件列表
            fileList.value = [...fileListMemory.value[type]]
        }
    }

    /**
     * 重置表单
     */
    const resetForm = () => {
        message.value = ''
        fileList.value = []
        activeType.value = 'text'
        uploading.value = false
        loading.value = false
        // 清空文件列表记忆
        fileListMemory.value = {
            text: [],
            image: [],
            video: [],
            audio: []
        }
    }

    /**
     * 初始化编辑数据
     */
    const initEditData = async () => {
        if (route.query.status === 'edit') {
            try {
                const { code, data } = await getUploadTaskInfoAPI({ i: route.query.post_id })
                if (code) {
                    message.value = data.note || ''
                    activeType.value = data.file_type || 'text'

                    // 如果有文件数据，初始化文件列表 - 使用data.files而不是data.meta
                    if (data.files && data.files.length > 0) {
                        const files = data.files.map(item => {
                            const fileItem = {
                                url: item.value,
                                status: 'done',
                                message: '已上传',
                                meta_id: item.meta_id,
                                name: item.name || ''
                            }

                            // 对于图片类型，添加isImage标记确保正确显示
                            if (activeType.value === 'image') {
                                fileItem.isImage = true
                            }

                            // 为了支持文件名显示，创建一个File对象
                            if (item.name) {
                                fileItem.file = new File([], item.name, { type: item.type || '' })
                            }

                            return fileItem
                        })

                        // 将文件列表保存到当前类型的记忆中
                        fileList.value = files
                        fileListMemory.value[activeType.value] = [...files]
                    }
                }
            } catch (error) {
                console.error('初始化编辑数据失败:', error)
            }
        }
    }

    return {
        // 状态
        uploading,
        loading,
        message,
        fileList,
        activeType,
        maxCount,
        canSubmit,

        // 方法
        beforeRead,
        afterRead,
        onDelete,
        delItem,
        onSubmit,
        switchType,
        resetForm,
        initEditData
    }
}