/**
 * 订单支付
 * @author: jiangfeng<jeff.jiang@yoho.cn>
 * @date: 2016/07/18
 */

'use strict';


const api = require('./pay-api');
const Promise = require('bluebird');
const co = Promise.coroutine;
const camelCase = global.yoho.camelCase;
const OrderData = require('./order');
const logger = global.yoho.logger;


const _ = require('lodash');

/**
 * 获取在线支付方式
 * @returns {*|Promise.<TResult>}
 */
const getOnlinePayProvider = () => {
    return api.getPayProvider().then(result => {
        if (!(result.code && result.code === 200)) {
            return [];
        }

        let online = _(result.data)
            .filter(i => _.includes(['Alipay'], i.payCode))
            .map(i => {
                return {
                    id: i.id,
                    name: i.payName,
                    img: i.payIcon,
                    selected: i.payCode === 'Alipay'
                };
            })
            .value();

        let nav = [
            {
                id: 'onlinePay',
                name: '支付宝等平台',
                selected: true
            }
        ];

        return {
            type: nav,
            onlinePay: online
        };
    });
};

/**
 * 获取订单详情
 * @param uid
 * @param code
 */
const getOrderInfo = (uid, code) => {
    return co(function *() {
        let orderData = yield OrderData.orderDetail(uid, code);

        if (orderData && orderData.data) {
            return camelCase(orderData.data);
        } else {
            return {};
        }
    })();
};

/**
 * 获取支付页数据
 * @param uid
 * @param code
 */
const getPayInfo = (uid, code) => {
    return co(function *() {
        let payment = yield Promise.all([getOnlinePayProvider(), getOrderInfo(uid, code)]);

        return {
            pay: payment[0],
            order: payment[1]
        };
    })();
};

/**
 * 获取支付方式的相关参数, (密钥等信息)
 * @param id
 */
const getPaymentInfo = (id) => {
    return co(function *() {
        let data = yield api.getPaymentInfo(id);

        if (data && data.code === 200 && data.data) {
            return camelCase(data.data);
        }
        return {};
    })();
};

/**
 * 获取订单支付银行信息
 * @param id
 */
const getBankByOrder = (id) => {
    return co(function *() {
        let data = yield api.getBankByOrder(id);

        if (data && data.code === 200 && data.data) {
            return camelCase(data.data);
        }
        return {};
    })();
};

/**
 * 设置订单支付银行
 * @param code
 * @param payment
 * @param bankCode
 */
const setOrderPayBank = (code, payment, bankCode) => {
    return co(function *() {
        let data = yield api.setOrderPayBank(code, payment, bankCode);

        return data;
    })();
};

/**
 * 更新订单支付银行
 * @param code
 * @param payment
 * @param bankCode
 */
const updateOrderPayBank = (code, payment, bankCode) => {
    return co(function *() {
        let data = yield api.updateOrderPayBank(code, payment, bankCode);

        return data;
    })();
};

/**
 * 支付确认
 * @param code
 * @param payment
 * @param uid
 */
const sendPayConfirm = (code, payment, uid) => {
    return co(function *() {
        let data = yield api.sendPayConfirm(code, payment, uid);

        return data;
    })();
};

/**
 * 支付成功,前端回调时,处理订单信息
 * @param payResult
 * @param uid
 */
const procOrderData = (payResult, uid) => {
    return co(function *() {
        let orderCode = payResult.orderCode;
        let result = {code: 400, message: ''};

        if (!orderCode) {
            result.message = '未查到订单信息，订单状态更新失败！';
            return result;
        } else {
            let orderInfo = yield OrderData.orderDetail(uid, orderCode);

            if (orderInfo && orderInfo.data) {
                let order = camelCase(orderInfo.data);
                let amount = order.paymentAmount;

                if (order.is_cancel === 'Y') {
                    logger.warn('front pay success but order is cancel.', {payResult: payResult, order: order});

                    api.sendMessage(order.mobile, 'error_sms', '支付成功,但订单已取消，订单号为' + orderCode);
                    return {code: 417, message: '支付成功，但订单已取消，需联系客服！'};
                }

                if (order.payment_status === 'N') {
                    logger.warn('front pay success but may be notify fail');
                }

                if (_.round(parseFloat(amount), 2) !== _.round(parseFloat(payResult.totalFee), 2)) {
                    logger.warn('front pay success but the amount is not same.', {payResult: payResult, order: order});
                    return {
                        code: 415,
                        message: '支付金额与订单金额不一致，订单状态更新失败！'
                    };
                }

                return {
                    code: 200,
                    message: '支付成功，请等待发货',
                    data: {
                        pay: amount,
                        orderCode: orderCode
                    }
                };

            } else {
                result.message = '未查到订单信息，订单状态更新失败！';
            }
        }

        return result;
    })();
};

module.exports = {
    getPayInfo,
    getPaymentInfo,
    getBankByOrder,
    setOrderPayBank,
    updateOrderPayBank,
    sendPayConfirm,
    procOrderData
};