/**
 * 订单支付
 * @author: xiaoxiao.hao<xiaoxiao.hao@yoho.cn>
 * @date: 2017/03/20
 */

'use strict';

const headerModel = require('../../../doraemon/models/simple-header');
const PayData = require('../models/pay');
const PayHelpers = require('../helpers/payment');
const _ = require('lodash');
const integerTest = /^\d+$/;

/**
 * 支付页
 * @param req
 * @param res
 * @param next
 */
const online = (req, res, next) => {
    let orderCode = req.query.ordercode || req.query.order_code;
    let uid = req.user.uid;

    if (!integerTest.test(orderCode)) {
        // 不合法订单号
        return next();
    }

    let PayModel = req.ctx(PayData);

    PayModel.getPayInfo(uid, orderCode).then(result => {
        let order = result.order;
        let amount = _.toNumber(order.payment_amount);
        let header = headerModel.setSimpleHeaderData() || {};

        if (!order.order_code) {
            // 不合法订单号
            return next();
        }

        order.payment_type = parseInt(order.payment_type, 10);

        if (amount <= 0 || order.payment_type === 2) {
            PayModel.deliveryData(order, PayModel.payments.delivery).then(orderInfo => {
                res.render('pay-success', {
                    module: 'shopping',
                    page: 'success',
                    simpleHeader: header,
                    order: orderInfo,
                    isDelivery: orderInfo.payment_type === 2
                });
            });
        } else {
            res.render('pay', Object.assign({
                module: 'shopping',
                page: 'pay',
                title: '支付页面',
                simpleHeader: header,
                username: decodeURIComponent(req.user.name) || ''
            }, result));
        }

    }).catch(next);

};

/**
 * 获取第三方支付跳转url
 * @param req
 * @param res
 * @param next
 */
const toPay = (req, res, next) => {
    let orderCode = req.body.code;
    let payType = req.body.payType;
    let user = req.user;

    if (!integerTest.test(orderCode)) {
        // 不合法订单号
        return next();
    }

    req.ctx(PayData).orderDetail(user.uid, orderCode).then(result => {
        if (result && result.data) {
            return req.ctx(PayHelpers).pay(Object.assign({
                clientIp: req.yoho.clientIp
            }, user), result.data, payType, req.protocol);
        } else {
            return {
                code: 400,
                message: '获取订单失败'
            };
        }
    }).then(result => {
        res.json(result);
    }).catch(next);
};

/**
 * 微信扫码支付页面
 * @param req
 * @param res
 * @param next
 */
const weixinQr = (req, res, next) => {
    let code = req.query.code;
    let qrcodeUrl = req.query.url;
    let uid = req.user.uid;
    let header = headerModel.setSimpleHeaderData() || {};

    if (!integerTest.test(code)) {
        // 不合法订单号
        return next();
    }

    req.ctx(PayData).orderDetail(uid, code).then(d => {
        d = d && d.data || {};
        res.render('weixin-pay', {
            module: 'shopping',
            page: 'wxpay',
            title: '微信扫码支付页面',
            simpleHeader: header,
            choosePayUrl: `//www.yohobuy.com/shopping/newpay?ordercode=${d.order_code}`,
            qrcodeUrl: qrcodeUrl,
            order: d
        });
    }).catch(next);
};

const weixinPayState = (req, res) => {
    let code = req.body.code;
    let uid = req.user.uid;

    if (!integerTest.test(code)) {
        return res.json({
            code: 401,
            message: '订单不存在'
        });
    }

    req.ctx(PayHelpers).getWxSign(uid, code).then(d => {
        return res.json(d);
    }).catch(() => {
        return res.json({});
    });
};

/**
 * 支付成功回调
 * @param req
 * @param res
 */
const callback = (req, res, next) => {
    let type = req.params.type;
    let payId = req.ctx(PayData).payments[type];
    let query = req.query;
    let header = headerModel.setSimpleHeaderData() || {};

    if (!payId) {
        return next();
    }

    // 银联、网银支付是post返回的
    if (type === 'unionpay' || type === 'chinabank') {
        query = req.body;
    }

    req.ctx(PayHelpers).afterPay(query, payId, req.user).then(result => {
        if (result.code === 200 && result.data && result.data.order) {
            res.render('pay-success', {
                module: 'shopping',
                page: 'success',
                simpleHeader: header,
                order: result.data.order
            });
        } else {
            res.render('pay-fail', {
                module: 'shopping',
                page: 'fail',
                point: result.point,
                simpleHeader: header,
                payName: result.payName
            });
        }
    }).catch(next);
};

// 支付确认
const sendPayConfirm = (req, res, next) => {
    let code = req.body.code;
    let payment = req.body.payment;
    let uid = req.user.uid;

    req.ctx(PayData).sendPayConfirm(code, payment, uid).then(result => {
        res.json(result);
    }).catch(next);
};

// 支付异步回调
const notify = (req, res, next) => {
    let type = req.params.type;
    let query = req.query;
    let payId = req.ctx(PayData).payments[type];

    if (!payId) {
        return res.json('');
    }

    req.ctx(PayHelpers).notifyPay(query, payId).then(result => {
        res.json(result);
    }).catch(next);
};


module.exports = {
    online,
    callback,
    toPay,
    weixinQr,
    weixinPayState,
    sendPayConfirm,
    notify
};