/*
 * @Author: chenminggui
 * @Date: 2022-03-08 13:55:33
 * @LastEditTime: 2022-06-29 10:30:20
 * @LastEditors: zhangzhuobin 1093998108@qq.com
 * @Description: 远程探视的待签署文件的弹窗
 * @FilePath: \ybm-patient-miniapp\mainWeixinMp\remote\Component\wait-sign\index.js
 */

// Component/index.js
import {
    fhHandleSignFile,
    fhPatientVerty,
    fhClientSignPay,
    fhGetFillInformation,
} from '../../../api/sign/index'
Component({
    /**
     * 组件的属性列表
     */
    properties: {
        payState: Boolean,
        payAmount: Number,
        authedFlag: Boolean,
        signId: Number,
        signArr: Array
    },
    // 监听器,监听signArr数组的变化
    observers: {
        'signArr'(signArr) {
            // 将变化后的signArr数组赋值给waitSignData
            this.setData({
                waitSignData: signArr
            })
            // 若当前签署任务完成,禁用签署按钮,调用handleClosePopup方法,关闭填写信息弹窗
            if (signArr[this.data.signindex].state) {
                this.setData({
                    isDisabled: false
                })
                this.handleClosePopup()
            }
        },

    },
    /**
     * 组件的初始数据
     */
    data: {
        popupShow: false,
        waitSignData: [],
        signId: "",
        // 签署信息填写状态
        isShowPopup: false,
        // 患者要填写的信息
        fillInformation: [],
        // 确认按钮是否禁用状态
        isDisabled: true,
        // 保存患者填写信息的数组
        saveFillInformationList: [],
        // 签署文件index
        signindex: 0,
        // 签署文件的ID
        fileSignId: 0,
        // 是否同意选项数组
        array: ['同意', '不同意'],
        // picker选项数组下标
        pickerIndex: 0,
        // 同意选项下的合同数据
        agreeData: [],
        // 不同意选项下的合同数据
        unAgreeData: [],
        // 患者填写合同时间数据
        signtimeData: []
    },
    /**
     * 组件的方法列表
     */
    methods: {
        // 关闭签署信息填写
        handleClosePopup() {
            this.setData({
                isShowPopup: false,
                pickerIndex: 0
            })
        },
        // 开启签署信息填写
        handleOpenPopup() {
            this.setData({
                isShowPopup: true
            })
        },

        // 获取患者填写合同相关信息
        async fhGetFillInformation(tempId) {
            wx.showLoading({
                title: '正在加载中',
                mask: true
            })
            try {
                const params = {
                    tempId: tempId,
                    signId: this.data.fileSignId
                }
                this.setData({
                    tempId
                })
                const results = await fhGetFillInformation(params)
                // 若获取到的results.results长度小于1,则表示该文件不需要进行签署信息填写,直接进行签署任务
                if (results.results.length < 1) {
                    this.setData({
                        fillInformation: []
                    })
                    this.handleSignFile()
                    return
                }
                console.log("我是患者填写合同相关信息", results.results)
                // 所有患者填写合同相关信息的数组(过滤含有时间的,因为含有时间选项的数据要前端自己填充时间传给后端,不需要展示)
                const fillDataList = results.results.filter(item => {
                    return item.fillValue.split('_')[5].indexOf('签署时间') === -1
                })

                // 患者填写合同信息时间数据
                const signtimeData = results.results.filter(item => {
                    return item.fillValue.split('_')[5].indexOf('签署时间') > -1
                })

                // 若含有签署的数据,则将fillData赋值为签署
                fillDataList.map(item => {
                    item.sequence = item.fillValue.split('_')[1]
                    if (item.fillValue.split('_')[5] === '签署') {
                        item.fillData = '签署'
                    }
                })

                // 给每条要填写的信息添加顺序标识,若含有同意/不同意字段的数据,则将fillData赋值为同意签署/不同意签署
                fillDataList.map(item => {
                    item.sequence = item.fillValue.split('_')[1]
                    if (item.fillValue.split('_')[5] === '同意') {
                        item.fillData = '同意'
                    }
                    if (item.fillValue.split('_')[5] === '不同意') {
                        item.fillData = '不同意'
                    }
                })
                // 根据顺序标识进行排序
                fillDataList.sort((a, b) => {
                    return a.sequence - b.sequence
                })
                console.log('我是data', fillDataList)

                // 过滤同意栏目的信息,fillValue切割后第四个值为1表示不同意
                const agreeData = fillDataList.filter(item => {
                    return item.fillValue.split('_')[4] !== '1'
                })
                console.log('我是同意选项', agreeData)

                // 过滤不同意栏目的信息,fillValue切割后第四个值为1表示不同意
                const unAgreeData = fillDataList.filter(item => {
                    return item.fillValue.split('_')[4] === '1'
                })
                console.log('我是不同意选项', unAgreeData)

                // 过滤真实需要展示在弹窗的合同信息数据,用于判断是否展示弹窗
                const realSignData = fillDataList.filter(item => {
                    return item.fillValue.split('_')[5].indexOf('签署') === -1
                })

                // 修改后的数据
                this.setData({
                    fillInformation: unAgreeData.length > 0 ? agreeData : fillDataList,
                    agreeData: agreeData,
                    unAgreeData: unAgreeData,
                    signtimeData: signtimeData,
                    realSignData: realSignData
                })

                console.log("我是患者填写合同相关信息", this.data.fillInformation)
                console.log("我是同意选项数组", this.data.agreeData)
                console.log("我是不同意选项数组", this.data.unAgreeData)
                console.log("我是患者填写合同时间数据", this.data.signtimeData)

                // 若真实需要展示在弹窗的合同信息数据长度小于1,则表示当前签署任务不需要展示弹窗,则直接调用签署方法函数进行签署
                if (realSignData.length < 1) {
                    this.handleSignFile()
                    return
                }

                // 调用监听确认按钮函数
                this.onDisabledChange()

            } catch (e) {
                console.log(e)
            } finally {
                // fillInformation数组长度大于0,表示该文件需要填写签署信息,则打开签署信息弹窗
                if (this.data.fillInformation.length > 0 && this.data.realSignData.length > 0) {
                    wx.hideLoading()
                    this.handleOpenPopup()
                }
            }
        },
        // 监听确认按钮是否禁用
        onDisabledChange() {
            let unFillList = this.data.fillInformation.filter(item => {
                if (item.fillData === null) {
                    return item.fillData === null
                }
                if (item.fillData === '') {
                    return item.fillData === ''
                }

            })
            if (unFillList.length > 0) {
                this.setData({
                    isDisabled: true
                })
            } else {
                this.setData({
                    isDisabled: false
                })
            }
            console.log("我是是否禁用按钮", this.data.isDisabled)
        },
        // 监听输入框的变化
        onInputChange({ currentTarget: { dataset }, detail }) {
            const { index } = dataset
            let { value, cursor } = detail
            let fillInformation = "fillInformation[" + index + "].fillData"
            this.setData({
                [fillInformation]: value
            })
            console.log(this.data.fillInformation)

            // 调用监听确认按钮函数
            this.onDisabledChange()
        },
        // 打开选择是否同意弹窗
        bindPickerChange: function (e) {
            console.log('picker发送选择改变，携带值为', e.detail.value)
            this.setData({
                pickerIndex: Number(e.detail.value)
            })
            if (e.detail.value === '0') {
                this.setData({
                    fillInformation: this.data.agreeData
                })
            }

            if (e.detail.value === '1') {
                this.setData({
                    fillInformation: this.data.unAgreeData
                })
            }

            // 调用是否禁用确认按钮的函数
            this.onDisabledChange()
        },
        handleClose() {
            this.setData({
                popupShow: false
            })
        },

        handleOpen(data) {
            this.setData({
                popupShow: true,
                waitSignData: data
            })
            console.log("传下来的支付状态", this.data.payState)
            // 向父组件传递是否获取签署数据的值的判断条件
            this.triggerEvent('getSignData', true)
        },

        /**
         * 点击查看事件
         * @id 文件id,
         * 
         */
        handleDetail(event) {
            console.log(event)
            const fileUrl = event.currentTarget.dataset.url
            wx.navigateTo({
                url: `/pages/sign-file/index?url=${encodeURIComponent(fileUrl)}`
            })
        },

        /**
         * 点击签署事件
         */
        handleSignFile() {
            // 法大大小程序AppId :
            // 测试环境：wx855361a721050c6b
            // 正式环境：wxa1439f77c6d06a15
            this.handleGetSignUrl().then(res => {
                if (res.success) {
                     // 获取小程序帐号信息
                    const accountInfo = wx.getAccountInfoSync().miniProgram
                    console.log('当前小程序版本环境', accountInfo.envVersion)
                     // 根据小程序环境信息适配跳转法大大的APPid
                    const appId = accountInfo.envVersion === 'release' ? 'wxa1439f77c6d06a15' : 'wx855361a721050c6b'
                    wx.navigateToMiniProgram({
                        appId: appId,
                        path: 'pages/h5sign/h5sign',
                        envVersion: 'release',
                        extraData: {
                            verifyUrl: res.results
                        }
                    })
                } else {
                    res.message === '患者未实名' ? this.handleToFaDaDaMini() : wx.showToast({ title: res.message, icon: 'none' })
                }
            })
        },
        /**
         * 文件签署功能
         * @param {*} tempId 文件模板ID 
         */
        async handleGetSignUrl(tempId) {
            wx.showLoading({
                title: '正在加载中',
                mask: true
            })
            let results = {};
            console.log(this.data.signId)
            try {
                const params = {
                    memberId: wx.getStorageSync('memberId'),
                    tempId: this.data.tempId,
                    signId: this.data.fileSignId
                }
                // 定义一个要传给后端的参数变量
                const fillData = []
                // 循环fillInformation,将需要的入参推进fillData里
                this.data.fillInformation.map(item => {
                    fillData.push({
                        fillKey: item.fillKey,
                        fillValue: item.fillValue,
                        fillData: item.fillData,
                        signId: this.data.fileSignId
                    })
                })

                //  引用dayjs,用于下方转换日期
                const dayjs = require('../../../src/js/dayjs/index')
                //  患者签署时间,取当前时间戳转化成日期
                const signTime = dayjs(new Date()).format('YYYY年MM月DD日 HH时mm分')
                console.log('我是签署时间', signTime)
                // 循环signtimeData,将患者签署时间通过每一项推进fillData里
                this.data.signtimeData.map(item => {
                    // 通过切割fillValue,匹配签署时间数组里符合当前患者的数据(即同意/不同意这两个状态下的签署时间), 将转换好的日期赋值给fillData
                    if (item.fillValue.split('_')[4] === fillData[0].fillValue.split('_')[4]) {
                        fillData.push({
                            fillKey: item.fillKey,
                            fillValue: item.fillValue,
                            fillData: signTime,
                            signId: this.data.fileSignId
                        })
                    } else {
                        // 不匹配则给fillData赋值为空
                        fillData.push({
                            fillKey: item.fillKey,
                            fillValue: item.fillValue,
                            fillData: '',
                            signId: this.data.fileSignId
                        })
                    }
                })

                // pickerIndex等于0表示当前选择的是同意,取不同意数据,等于1表示当前选择的是不同意,取同意的数据
                const dataList = this.data.pickerIndex === 0 ? this.data.unAgreeData : this.data.agreeData
                console.log('我是dataList', dataList)
                // dataList的数据循环后,将需要的入参推进fillData里
                dataList.map(item => {
                    fillData.push({
                        fillKey: item.fillKey,
                        fillValue: item.fillValue,
                        fillData: "",
                        signId: this.data.fileSignId
                    })
                })

                const bodyParams = fillData
                console.log("我是signId", this.data.signId)
                console.log("我是params", params)
                console.log("我是bodyParams", bodyParams)
                results = await fhHandleSignFile(this.data.signId, params, bodyParams)
                wx.hideLoading();
            } catch (e) {
                wx.hideLoading();
                results = {
                    success: false,
                    message: e
                }
            }
            return Promise.resolve(results)
        },

        /**
         * 获取跳转实名认证的路径
         */
        async getVertyPatient() {
            const params = {
                accounType: 1,
                patientId: getApp().globalData.baseInfo.memberId,
                url: ``
            }
            const {
                results
            } = await fhPatientVerty(params);
            return Promise.resolve(results)
        },

        /**
         * 跳转法大大小程序逻辑
         */
        handleToFaDaDaMini() {
            console.log('准备获取地址')
            wx.showModal({
                title: "提示",
                content: "您当前未进行实名认证,请前往填写实名信息",
                success: (flag) => {
                    if (flag.confirm) {
                        wx.showLoading({
                            title: "加载中",
                            mask: true
                        })
                        this.getVertyPatient().then(res => {
                            console.log('获取地址成功', res)
                            // 法大大小程序AppId :
                            // 测试环境：wx855361a721050c6b
                            // 正式环境：wxa1439f77c6d06a15
                            // 获取小程序帐号信息
                            const accountInfo = wx.getAccountInfoSync().miniProgram
                            console.log('当前小程序版本环境', accountInfo.envVersion)
                            // 根据小程序环境信息适配跳转法大大的APPid
                            const appId = accountInfo.envVersion === 'release' ? 'wxa1439f77c6d06a15' : 'wx855361a721050c6b'
                            wx.navigateToMiniProgram({
                                appId: appId,
                                path: 'pages/result-loading/result-loading?verifyUrl=' + encodeURIComponent(res),
                                envVersion: 'release'
                            })
                            wx.hideLoading();
                        })
                    }
                }
            })

        },
        /**
         * 立即支付流程
         */
        async handlePayWechat() {
            wx.showLoading({
                title: "加载中",
                mask: true
            })
            try {
                const params = {
                    memberId: getApp().globalData.baseInfo.memberId
                }
                const bodyParams = {
                    needSmsCode: '',
                    payType: 1
                }
                const res = await fhClientSignPay(this.data.waitSignData[0].documentId, params, bodyParams)
                const results = res.results
                if (res.success) {
                    wx.requestPayment({
                        timeStamp: results.timeStamp,
                        nonceStr: results.nonceStr,
                        signType: results.signType,
                        paySign: results.paySign,
                        package: results.prepayId,
                        success: (res) => {
                            wx.hideLoading();
                            wx.showToast({
                                title: '支付成功',
                                icon: 'success',
                            })
                            this.triggerEvent('handleSuccessPay', {}, {})
                            // 支付成功时,向父组件传递该方法
                            this.triggerEvent('payStatusChange')
                        },
                        fail: (error) => {
                            wx.hideLoading();
                            console.log(error)
                        }
                    })
                }
            } catch (e) {
                console.log('error', e)
            }
        },
        // 认证或签署方法
        handleCertificationSigned(event) {
            console.log("我是event", event.currentTarget.dataset)
            this.setData({
                signindex: event.currentTarget.dataset.signindex,
                fileSignId: event.currentTarget.dataset.filesignid,
            })
            if (this.data.payState) {
                const authedFlag = wx.getStorageSync('authedFlag')
                console.log("用户是否进行认证", authedFlag)
                if (authedFlag) {
                    console.log("去签署")
                    this.fhGetFillInformation(event.currentTarget.dataset.id)
                } else {
                    console.log("认证")
                    this.handleToFaDaDaMini()
                }
            } else {
                // 未支付弹出提示窗
                wx.showModal({ title: '提示', content: '签署任务未支付', showCancel: false })
            }

        }
    }
})