import {
    getUserInfo,
    getMessage,
    getContentByMsgId,
    hasRead,
    removeReaded,
    restoreTrash
} from '@/api/user'
import { setToken, getToken, settimeStamp, gettimeStamp, setnonce, getnonce, setsign, getsign } from '@/libs/util'
// this.$store.commit('index', changeLogin)
export default {
    state: {
        userName: '',
        userId: '',
        avatarImgPath: '',
        token: getToken(),
        timestamp: gettimeStamp(),
        nonce: getnonce(),
        sign: getsign(),
        access: '',
        logo: '',
        hasGetInfo: false,
        unreadCount: 0,
        messageUnreadList: [],
        messageReadedList: [],
        messageTrashList: [],
        messageContentStore: {},
        token: localStorage.getItem('token') ? localStorage.getItem('token') : '',
        blockitem: 'configs',
        showRainbow: 0,
        projectId: ''
    },
    mutations: {
        setmenuitem (state, blockitem) {
            state.blockitem = blockitem
        },
        setAvatar (state, avatarPath) {
            state.avatarImgPath = avatarPath
        },
        setUserId (state, id) {
            state.userId = id
        },
        setLogo (state, logo) {
            state.logo = logo
        },
        setUserName (state, name) {
            state.userName = name
        },
        setAccess (state, access) {
            state.access = access
        },
        setToken (state, token) {
            state.token = token
            setToken(token)
        },
        timestamp (state, timestamp) {
            state.timestamp = timestamp
            settimeStamp(timestamp)
        },
        nonce (state, nonce) {
            state.nonce = nonce
            setnonce(nonce)
        },
        sign (state, sign) {
            state.sign = sign
            setsign(sign)
        },
        setHasGetInfo (state, status) {
            state.hasGetInfo = status
        },
        setMessageCount (state, count) {
            state.unreadCount = count
        },
        setMessageUnreadList (state, list) {
            state.messageUnreadList = list
        },
        setMessageReadedList (state, list) {
            state.messageReadedList = list
        },
        setMessageTrashList (state, list) {
            state.messageTrashList = list
        },
        updateMessageContentStore (state, { msg_id, content }) {
            state.messageContentStore[msg_id] = content
        },
        moveMsg (state, { from, to, msg_id }) {
            const index = state[from].findIndex(_ => _.msg_id === msg_id)
            const msgItem = state[from].splice(index, 1)[0]
            msgItem.loading = false
            state[to].unshift(msgItem)
        },
        changeLogin (state, user) {
            state.token = user.token
            localStorage.setItem('token', user.token)
        },
        changetimestamp (state, user) {
            state.timestamp = user.timestamp
            localStorage.setItem('timestamp', user.timestamp)
        },
        changesign (state, user) {
            state.sign = user.sign
            localStorage.setItem('sign', user.sign)
        },
        changenonce (state, user) {
            state.nonce = user.nonce
            localStorage.setItem('nonce', user.nonce)
        },
        showRainbow (state, user) {
            state.showRainbow = user.showRainbow;
            // localStorage.setItem('nonce', user.nonce)
        },
        setProjectId (state, projectId) {
            state.projectId = projectId
        }
    },
    getters: {
        messageUnreadCount: state => state.messageUnreadList.length,
        messageReadedCount: state => state.messageReadedList.length,
        messageTrashCount: state => state.messageTrashList.length
    },
    actions: {

    // 退出登录
        handleLogOut ({ state, commit }) {
            // 如果你的退出登录无需请求接口，则可以直接使用下面三行代码而无需使用logout调用接口
            commit('setToken', '')
            commit('setAccess', [])
            // window.location.reload()

            // resolve()
            // return new Promise((resolve, reject) => {

            // logout(state.token).then(() => {

            // commit('setToken', '')
            // commit('setAccess', [])
            // resolve()
            // })
            // .catch(err => {
            //   reject(err)
            // })

            // })
        },
        // 获取用户相关信息
        getUserInfo ({ state, commit }) {
            return new Promise((resolve, reject) => {
                try {
                    getUserInfo(state.token).then(res => {
                        const data = res.data.data;
                        commit('setAvatar', data.avatar);
                        commit('setUserName', data.name);
                        commit('setUserId', data.user_id);
                        commit('setAccess', data.access);
                        commit('setLogo', data.logo);
                        commit('setHasGetInfo', true);
                        commit('showRainbow', data);
                        commit('setProjectId', data.projectId);
                        resolve(data)
                    }).catch(err => {
                        reject(err)
                    })
                } catch (error) {
                    reject(error)
                }
            })
        },
        // 此方法用来获取未读消息条数，接口只返回数值，不返回消息列表
        // getUnreadMessageCount ({ state, commit }) {
        //   getUnreadCount().then(res => {
        //     const { data } = res
        //     commit('setMessageCount', data)
        //   })
        // },
        // 获取消息列表，其中包含未读、已读、回收站三个列表
        getMessageList ({ state, commit }) {
            return new Promise((resolve, reject) => {
                getMessage().then(res => {
                    const { unread, readed, trash } = res.data
                    commit('setMessageUnreadList', unread.sort((a, b) => new Date(b.create_time) - new Date(a.create_time)))
                    commit('setMessageReadedList', readed.map(_ => {
                        _.loading = false
                        return _
                    }).sort((a, b) => new Date(b.create_time) - new Date(a.create_time)))
                    commit('setMessageTrashList', trash.map(_ => {
                        _.loading = false
                        return _
                    }).sort((a, b) => new Date(b.create_time) - new Date(a.create_time)))
                    resolve()
                }).catch(error => {
                    reject(error)
                })
            })
        },
        // 根据当前点击的消息的id获取内容
        getContentByMsgId ({ state, commit }, { msg_id }) {
            return new Promise((resolve, reject) => {
                let contentItem = state.messageContentStore[msg_id]
                if (contentItem) {
                    resolve(contentItem)
                } else {
                    getContentByMsgId(msg_id).then(res => {
                        const content = res.data
                        commit('updateMessageContentStore', { msg_id, content })
                        resolve(content)
                    })
                }
            })
        },
        // 把一个未读消息标记为已读
        hasRead ({ state, commit }, { msg_id }) {
            return new Promise((resolve, reject) => {
                hasRead(msg_id).then(() => {
                    commit('moveMsg', {
                        from: 'messageUnreadList',
                        to: 'messageReadedList',
                        msg_id
                    })
                    commit('setMessageCount', state.unreadCount - 1)
                    resolve()
                }).catch(error => {
                    reject(error)
                })
            })
        },
        // 删除一个已读消息到回收站
        removeReaded ({ commit }, { msg_id }) {
            return new Promise((resolve, reject) => {
                removeReaded(msg_id).then(() => {
                    commit('moveMsg', {
                        from: 'messageReadedList',
                        to: 'messageTrashList',
                        msg_id
                    })
                    resolve()
                }).catch(error => {
                    reject(error)
                })
            })
        },
        // 还原一个已删除消息到已读消息
        restoreTrash ({ commit }, { msg_id }) {
            return new Promise((resolve, reject) => {
                restoreTrash(msg_id).then(() => {
                    commit('moveMsg', {
                        from: 'messageTrashList',
                        to: 'messageReadedList',
                        msg_id
                    })
                    resolve()
                }).catch(error => {
                    reject(error)
                })
            })
        }
    }
}
