'use strict';

const _ = require('lodash');
const helpers = global.yoho.helpers;
const paymentProcess = require(global.utils + '/payment-process');
const shoppingAPI = require('./shopping');
const logger = global.yoho.logger;
const payModel = require('../models/pay');

/**
 * 调用购物车结算接口返回的数据处理
 *
 *
 *
 * @param int $uid 用户ID
 * @param string $cartType 购物车类型，ordinary表示普通购物车
 * @param array $orderInfo cookie中记录的一些订单有关数据
 * @param string $limitProductCode 限购商品码，用户限购商品购买
 * @param string $sku 商品sku，用于限购商品购买
 * @param stirng $skn 商品skn，用于限购商品购买
 * @param int $buyNumber 购买商品数目，用户限购商品支付
 * @param bool $isAjax 是否是异步请求
 * @return array 接口返回的数据
 */
exports.cartPay = (params) => {
    let result = {};
    let skuList = [];
    let isLimitGoods = params.skn && params.sku && params.buyNumber; // 存在sku, skn 和buyNumber时为限购商品
    let orderComputeAPI = null;

    if (isLimitGoods) {
        skuList.push({
            type: 'limitcode',
            limitproductcode: params.limitProductCode,
            buy_number: params.buyNumber,
            skn: params.skn,
            sku: params.sku
        });

        result.isLimit = true;
    }

    // cookie保存的数据
    if (params.orderInfo && !_.isEmpty(params.orderInfo)) {
        params.orderInfo.paymentType = params.orderInfo.paymentType ? params.orderInfo.paymentType : '';
        orderComputeAPI = shoppingAPI.orderComputeAPI({
            uid: params.uid,
            cart_type: params.cartType,
            delivery_way: params.orderInfo.deliveryId,
            payment_type: params.orderInfo.paymentType,
            coupon_code: params.orderInfo.couponCode,
            use_yoho_coin: params.orderInfo.yohoCoin,
            product_sku_list: skuList,
            activityInfo: params.activityInfo
        });
    }

    // 区分套餐量贩和普通商品
    let cartPayAPI;
    let cartPayAPIParams = {
        uid: params.uid,
        cart_type: params.cartType,
        product_sku_list: skuList
    };

    if (params.activityInfo) {
        cartPayAPI = shoppingAPI.cartPayAPI(_.assign(cartPayAPIParams, {
            activityInfo: params.activityInfo
        }));
    } else {
        cartPayAPI = shoppingAPI.cartPayAPI(cartPayAPIParams);
    }

    return Promise.all([
        cartPayAPI, // 0. 订单数据
        orderComputeAPI,
        shoppingAPI.getValidCouponCount(params.uid) // 2. 有效优惠券
    ]).then(res => {
        let pay = res[0];
        let orderCompute = _.get(res[1], 'data', {});
        let validCouponCount = _.get(res[2], 'data.count', 0);

        let goodsList = _.get(pay, 'data.goods_list', []);

        if (_.isEmpty(goodsList)) {
            logger.info(`orderEnsure: goodsList is empty, isLimitGoods: ${isLimitGoods}`);
            if (isLimitGoods) {
                result.error = true;
                result.message = pay.message;
            } else {
                result.cartUrl = helpers.urlFormat('/cart/index/index');
            }

            return result;
        }

        result = Object.assign(
            result,
            paymentProcess.tranformPayment(pay.data, params.orderInfo, params.cartType, skuList, orderCompute),

            {
                coupon: paymentProcess.coupon(validCouponCount, params.orderInfo, orderCompute)
            }
        );

        return result;
    });
};

/**
 * 购物车结算--支付方式和配送方式选择以及是否使用有货币接口返回的数据处理
 *
 * @param int $uid 用户ID
 * @param string $cartType 购物车类型，ordinary表示普通购物车
 * @param int $deliveryWay 配送方式，1表示普通快递，2表示顺丰速运
 * @param int $paymentType 支付方式，1表示在线支付，2表示货到付款
 * @param string $couponCode 优惠券码
 * @param mixed $yohoCoin 使用的有货币数量
 * @param string $skuList 购买限购商品时需要传递的参数
 * @return array 接口返回的数据
 */
exports.orderCompute = (params) => {
    return shoppingAPI.orderComputeAPI(params).then(result => {
        if (result && result.data) {
            result.data.use_yoho_coin = paymentProcess.transPrice(result.data.use_yoho_coin);
            result.data.yohoCoinCompute = paymentProcess.yohoCoinCompute(result.data);
            return result.data;
        } else {
            return {};
        }
    });
};


exports.ticketsOrderCompute = (uid, productSku, buyNumber, yohoCoin) => {
    return shoppingAPI.checkTickets(uid, productSku, buyNumber, yohoCoin).then(result => {
        if (result && result.data) {
            let resu = {};

            result.data.shopping_cart_data.use_yoho_coin =
                paymentProcess.transPrice(result.data.shopping_cart_data.use_yoho_coin);
            resu = result.data.shopping_cart_data;
            resu.yohoCoinCompute = paymentProcess.yohoCoinCompute(result.data.shopping_cart_data);

            return resu;
        } else {
            return {};
        }
    });
};

/**
 * 购物车结算--提交结算信息
 *
 * @param int $uid 用户ID
 * @param int $addressId 地址ID
 * @param int $cartType 购物车类型ID
 * @param int $deliveryTime 寄送时间ID
 * @param int $deliveryWay 寄送方式ID
 * @param array $invoices 发票参数数组
 * @param int $paymentId 支付方式ID
 * @param int $paymentType 支付类型ID
 * @param string $remark 留言
 * @param string $couponCode 优惠券码
 * @param mixed $yohoCoin 使用的有货币数量或为空
 * @param string $skuList 购买限购商品时需要传递的参数
 * @param string|null $userAgent 联盟过来用户下单时需要的User-Agent信息
 * @param int $times
 * @param null $activityInfo 套餐数据
 * @param otherParams 其他参数
 * @return array 接口返回的数据
 */
exports.orderSub = (params) => {
    if (!params.qhy_union) {
        params.qhy_union = '';
    }

    if (!params.userAgent) {
        params.userAgent = null;
    }

    if (!params.times) {
        params.times = 1;
    }

    if (!params.activityInfo) {
        params.activityInfo = null;
    }

    if (!params.address_id) {
        return Promise.resolve({code: 401, message: '配送地址不能为空'});
    }

    if (!params.delivery_time) {
        return Promise.resolve({code: 402, message: '请选择配送时间'});
    }

    if (!params.delivery_way) {
        return Promise.resolve({code: 403, message: '请选择配送方式'});
    }

    return shoppingAPI.orderSub(params).then(orderSubRes => {
        let finalResult = {};

        if (orderSubRes && orderSubRes.data && orderSubRes.data.is_hint === 'Y') {
            finalResult.code = 409;

            if (orderSubRes.data.hintInfo) {
                let productName = _.get('orderSubRes', 'data.hintInfo.productName', '');

                if (productName.length > 50) { // TODO 需要检查长度是否正确
                    orderSubRes.data.hintInfo.productName =
                           productName.substring(0, 47) + '...';
                }

                finalResult.message = [
                    encodeURI(productName + _.get(orderSubRes, 'data.hintInfo.suffix', '')),
                    encodeURI(_.get(orderSubRes, 'data.hintInfo.lastLine', ''))
                ];
            }

            finalResult.buttons = [
                {
                    href: helpers.urlFormat('/cart/index/index'),
                    text: '重新选择商品',
                    class: ''
                },
                {
                    href: '',
                    text: '继续结算',
                    class: 'order-tip-btnred'
                }
            ];
        } else if (orderSubRes && orderSubRes.code) {
            finalResult = orderSubRes;
        } else {
            finalResult = {
                code: 400,
                message: '出错啦'
            };
        }

        return finalResult;
    });

};

/**
 * 处理优惠券列表数据
 *
 * @param int $uid 用户ID
 * @return array|mixed 处理之后的优惠券数据
 */
exports.getCouponList = params => {
    let result = {
        availableCoupons: [],
        usableFreesCoupons: [],
        notAvailableCoupons: [],
    };

    return shoppingAPI.listCoupon({
        uid: params.uid,
        delivery_way: params.delivery_way,
        is_group_frees: params.is_group_frees
    }).then(coupons => {
        let usableCoupons = _.get(coupons, 'data.usable_coupons', []);
        let freesCoupons = _.get(coupons, 'data.usable_frees_coupons', []);
        let unusableCoupons = _.get(coupons, 'data.unusable_coupons', []);

        let orderInfoUsableUsualCode = _.get(params, 'orderInfo.usable_usual_code', '');
        let orderInfoUsableFreeCode = _.get(params, 'orderInfo.usable_free_code', '');

        let procCouponsData = coupon => {
            return {
                couponCode: coupon.coupon_code,
                couponDetailInfomation: coupon.coupon_name,
                couponValue: coupon.coupon_value,
                couponValidity: coupon.coupon_validity,
                checked: coupon.coupon_code === orderInfoUsableUsualCode ||
                    coupon.coupon_code === orderInfoUsableFreeCode
            };
        };

        result.availableCoupons = usableCoupons.map(procCouponsData); // 可用优惠券
        result.usableFreesCoupons = freesCoupons.map(procCouponsData); // 运费券
        result.notAvailableCoupons = unusableCoupons.map(procCouponsData); // 不可用优惠券

        return result;
    });
};

exports.useCouponCode = (uid, couponCode) => {
    let result = {code: 400, message: '出错啦～'};

    if (!couponCode) {
        return Promise.resolve({
            code: 401,
            message: '优惠券代码为空'
        });
    }

    return shoppingAPI.useCoupon(uid, couponCode)
        .catch(() => result);
};

/**
 * jit拆单数据(结算页和订单详情页)
 * @param type $uid 用户uid
 * @param type $cartType 购物车类型
 * @param type $skuList cookie中记录的一些订单有关数据
 * @param type $orderCode 订单号
 * @param type $sessionKey 用户会话
 * @param type $deliveryId 配送方式，1表示普通快递，2表示顺丰速运
 * @param type $paymentType 支付方式，1表示在线支付，2表示货到付款
 * @param type $couponCode 优惠券码
 * @param type $yohoCoin 使用的有货币数量
 * @return type
 */
exports.jitDetailData = (uid, cartType, skuList, orderCode, sessionKey,
    deliveryId, paymentType, couponCode, yohoCoin) => {

    // 订单详情页拆单
    if (orderCode) {
        return payModel.getOtherDetail({
            uid: uid,
            orderCode: orderCode,
            sessionKey: sessionKey
        }).then(result => {
            return paymentProcess.transformJit(_.get(result, 'data.package_list', []));
        });
    }

    // 购物车拆单
    if (deliveryId) {

        // 购物车选择改变字段，重新运算订单数据
        return shoppingAPI.orderComputeAPI({
            uid: uid,
            cart_type: cartType,
            delivery_way: deliveryId,
            payment_type: paymentType,
            coupon_code: couponCode,
            use_yoho_coin: yohoCoin,
            product_sku_list: skuList
        }).then(result => {
            return paymentProcess.transformJit(_.get(result, 'data.package_list', []));
        });
    } else {
        return shoppingAPI.cartPayAPI({
            uid: uid,
            cart_type: cartType,
            product_sku_list: skuList
        }).then(result => {
            return paymentProcess.transformJit(_.get(result, 'data.shopping_cart_data.package_list', []));
        });
    }
};