/**
 * 支付
 * @author: jing.li<jing.li@yoho.cn>
 * @date: 2016/10/25
 */

'use strict';

const serviceAPI = global.yoho.ServiceAPI;
const utils = '../../../utils';
const productProcess = require(`${utils}/product-process`);
const ApipayConfig = global.yoho.config.alipayConfig;
const md5 = require('yoho-md5');
const payApiModel = require('./pay-api');
const _ = require('lodash');
const co = require('bluebird').coroutine;
const logger = global.yoho.logger;
const stringProcess = require(`${global.utils}/string-process`);

class payModel extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
        this.ctx = _.get(ctx, 'req.ctx');
    }

    // 资源位
    _getBanner(param) {
        return this.get({
            api: serviceAPI,
            url: 'operations/api/v5/resource/get',
            data: {
                content_code: param.contentCode,
                platform: 'iphone'
            },
            param: { code: 200 }
        }).then((result) => {
            result = result.data;

            return result;
        });
    }

    // 购买此商品的用户也购买了
    _getOthersBuy2(param) {
        return this.get({data: {
            method: 'app.recommend.purchased',
            productSkn: param.skn,
            udid: param.uid,
            rec_pos: '100005',
            limit: 2,
            client_id: param.client_id
        }, param: { code: 200 }}).then((result) => {
            if (result && result.data && result.data.product_list) {
                return productProcess.processProductList(result.data.product_list);
            }

        });
    }

    // 订单信息
    getOtherDetail(param) {
        if (!param.uid || !param.orderCode || !stringProcess.isNumeric(param.orderCode)) {
            return Promise.resolve({});
        }

        return this.get({data: {
            method: 'app.SpaceOrders.detail',
            uid: param.uid,
            order_code: param.orderCode,
            session_key: param.sessionKey
        }, param: { code: 200 }}).then(result => {
            return result;
        });
    }

    // 购买此商品的用户也购买了,要先从订单详情获取商品skn
    _getOthersBuy(param) {
        return Promise.all([
            this.getOtherDetail(param)
        ]).then((result) => {

            let goodSkn = '';

            if (result && result[0] && result[0].data && result[0].data.order_goods) {
                goodSkn = result[0].data.order_goods[0].product_skn;
            }

            return this._getOthersBuy2(Object.assign(param, { skn: goodSkn }));

        }).then((result) => {

            return result;
        });
    }

    /**
     * 获取订单支付银行信息
     * @param id
     */
    getBankByOrder(id) {
        let self = this;

        return co(function* () {
            let result = yield self.ctx(payApiModel).getBankByOrder(id);

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

    /**
     * 设置订单支付银行
     * @param code
     * @param payment
     * @param bankCode
     */
    setOrderPayBank(code, payment, bankCode) {
        let self = this;

        return co(function* () {
            let data = yield self.ctx(payApiModel).setOrderPayBank(code, payment, bankCode);

            return data;
        })();
    }

    /**
     * 获取支付方式的相关参数, (密钥等信息)
     * @param id
     */
    getPaymentInfo(id) {
        let self = this;

        return co(function* () {
            let result = yield self.ctx(payApiModel).getPaymentInfo(id);

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

    /**
     * 支付确认
     * @param code
     * @param payment
     * @param uid
     */
    sendPayConfirm(code, payment, uid) {
        let self = this;

        return co(function* () {
            let data = yield self.ctx(payApiModel).sendPayConfirm(code, payment, uid);

            return data;
        })();
    }

    /**
     * 更新订单支付方式
     * @param code
     * @param payment
     * @param uid
     * @returns {*}
     */
    updateOrderPayment(code, payment, uid) {
        return this.get({data: {
            method: 'app.SpaceOrders.updateOrdersPaymentByCode',
            order_code: code,
            payment: payment,
            uid: uid
        }});
    }

    /**
     * 更新订单支付银行
     * @param code
     * @param payment
     * @param bankCode
     */
    updateOrderPayBank(code, payment, bankCode) {
        let self = this;

        return co(function* () {
            let data = yield self.ctx(payApiModel).updateOrderPayBank(code, payment, bankCode);

            return data;
        })();
    }

    /**
     * 支付成功,前端回调时,处理订单信息
     * @param payResult
     * @param uid
     * @param sessionKey
     */
    procOrderData(payResult, uid, sessionKey) {
        let self = this;

        return co(function* () {
            let orderCode = payResult.orderCode;
            let result = { code: 400, message: '' };

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

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

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

                        self.ctx(payApiModel).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: {
                            order: order
                        }
                    };

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

            return result;
        })();
    }

    /**
     * 支付中心
     * @param params
     */
    payCenter(params) {

        return this.getOtherDetail({
            uid: params.uid,
            orderCode: params.orderCode,
            sessionKey: params.sessionKey
        }).then(result => {
            return _.get(result, 'data', {});
        });
    }

    // 货到付款
    getPayCod(param) {
        return Promise.all([
            this._getBanner(param),
            this._getOthersBuy(param),
            this.getOtherDetail(param)
        ]).then((result) => {

            let resu = {
                match: true,
                banner: [],
                othersBuy: []
            };

            if (result && result[0]) {
                _.forEach(result[0], function(val) {
                    if (val.template_name === 'single_image') {
                        resu.banner = val;
                    } else if (val.template_name === 'text') {
                        resu.prompt = val.data;
                    }
                });
            }

            if (result && result[1]) {
                resu.othersBuy = result[1];
            }

            if (result && result[2] && result[2].data && result[2].data.payment_amount) {
                resu.payment = result[2].data.payment_amount;

            } else {
                resu.match = false;
            }

            resu.orderCode = param.orderCode;

            resu.orderUrl = '/home/orders/detail?order_code=' + param.orderCode;

            return resu;
        });
    }

    _raw(args) {
        let keys = Object.keys(args);

        keys = keys.filter(k => {
            let keyValueCheck =
                k === 'sign' ||
                k === 'sign_type' ||
                k === 'code' ||
                args[k] === '' ||
                args[k] === 'undefined';

            return !keyValueCheck;
        }).sort();

        return keys.map(k => {
            return k + '=' + decodeURI(args[k]);
        }).join('&');
    }

    /**
     * 验证返回结果的正确性
     */
    _checkResponse(params) {
        if (!params.sign) {
            return false;
        }
        let rawResult = this._raw(params);
        let sign = rawResult + ApipayConfig.alipayKey;
        let md5Result = md5(sign);

        return md5Result === params.sign;
    }

    /**
     * 支付宝支付结果校验
     */
    alipayResultVerify(params) {
        let checkResult = {};

        if (params.q) {
            delete params.q;
        }

        if (!this._checkResponse(params)) {
            checkResult.payResult = false;
        } else {
            _.assign(checkResult, {
                bankName: '',
                orderCode: params.out_trade_no,
                payResult: params.trade_status === 'TRADE_SUCCESS',
                payTime: params.gmt_payment || '',
                totalFee: params.total_fee,
                resultMsg: params.notify_type,
                payOrderCode: params.out_trade_no,
                tradeNo: params.trade_no,
                bankBillNo: ''
            });
        }

        return checkResult;
    }

    // 支付宝支付
    getPayAli(param) {
        return Promise.all([
            this._getBanner(param),
            this._getOthersBuy(param),
            this.getOtherDetail(param)
        ]).then((result) => {

            let resu = {
                match: true,
                banner: [],
                othersBuy: []
            };

            if (result && result[0]) {
                _.forEach(result[0], function(val) {
                    if (val.template_name === 'single_image') {
                        resu.banner = val;
                    } else if (val.template_name === 'text') {
                        resu.prompt = val.data;
                    }
                });
            }

            if (result && result[1]) {
                resu.othersBuy = result[1];
            }

            if (result && result[2] && result[2].data && result[2].data.payment_amount) {
                resu.packageTitle = _.get(result[2], 'data.package_title', '');

                resu.payment = result[2].data.payment_amount;

                if (param.isPay && param.isPay === true) {
                    if (result[2].data.payment_status && result[2].data.payment_status === 'Y') {
                        resu.payWay = false;
                    } else {
                        resu.isCancel = true;
                    }
                } else {
                    resu.payWay = true;
                }

            } else {
                resu.match = false;
            }

            resu.orderCode = param.orderCode;

            resu.orderUrl = '/home/orders/detail?order_code=' + param.orderCode;

            return resu;
        });
    }
}

module.exports = payModel;