'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 float|string $price 价格
 * @param boolean $isSepcialZero 是否需要特殊的0，默认否
 * @return float|string 转换之后的价格
 */
const transPrice = (price, isSepcialZero) => {
    if (!price) {
        price = 0;
    }

    if (!isSepcialZero) {
        isSepcialZero = false;
    }

    if ((price || isSepcialZero) && _.isNumber(price)) {
        return price.toFixed(2);
    } else {
        return price;
    }
};

/**
 * 调用购物车结算接口返回的数据处理
 *
 *
 *
 * @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 = (uid, cartType, orderInfo, limitProductCode, sku, skn, buyNumber, activityInfo) => {
    let result = {};
    let skuList = [];
    let isLimitGoods = skn && sku && buyNumber; // 存在sku, skn 和buyNumber时为限购商品
    let orderComputeAPI = null;

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

        result.isLimit = true;
    }

    // cookie保存的数据
    if (orderInfo) {
        orderInfo.paymentType = orderInfo.paymentType ? orderInfo.paymentType : '';
        orderComputeAPI = shoppingAPI.orderComputeAPI(
            uid,
            cartType,
            orderInfo.deliveryId,
            orderInfo.paymentType,
            orderInfo.couponCode,
            orderInfo.yohoCoin, skuList, activityInfo
        );
    }

    // 区分套餐量贩和普通商品
    let cartPayAPI;

    if (activityInfo) {
        cartPayAPI = shoppingAPI.cartPayAPI(uid, cartType, 0, skuList, activityInfo);
    } else {
        cartPayAPI = shoppingAPI.cartPayAPI(uid, cartType, 0, skuList);
    }

    return Promise.all([
        cartPayAPI, // 0. 订单数据
        orderComputeAPI,
        shoppingAPI.getValidCouponCount(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, orderInfo, cartType, skuList, orderCompute),

            {
                coupon: paymentProcess.coupon(validCouponCount, 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 = (uid, cartType, deliveryWay, paymentType, couponCode, yohoCoin, skuList, activityInfo) => {
    return shoppingAPI.orderComputeAPI(uid, cartType, deliveryWay, paymentType,
        couponCode, yohoCoin, skuList, activityInfo).then(result => {
            if (result && result.data) {
                result.data.use_yoho_coin = 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) {
            result.data.shopping_cart_data.use_yoho_coin = transPrice(result.data.shopping_cart_data.use_yoho_coin);
            result.data.yohoCoinCompute = paymentProcess.yohoCoinCompute(result.data.shopping_cart_data);

            return result.data;
        } 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 $qhyUnio 友盟有关信息
 * @param string|null $userAgent 联盟过来用户下单时需要的User-Agent信息
 * @param int $times
 * @param null $activityInfo 套餐数据
 * @param isWechat 是否是微信商城
 * @return array 接口返回的数据
 */
exports.orderSub = (uid, addressId, cartType, deliveryTime,
    deliveryWay, invoices, paymentId, paymentType, remark,
    couponCode, yohoCoin, skuList, qhyUnio,
    userAgent, times, activityInfo, ip, isWechat) => {
    if (!qhyUnio) {
        qhyUnio = '';
    }

    if (!userAgent) {
        userAgent = null;
    }

    if (!times) {
        times = 1;
    }

    if (!activityInfo) {
        activityInfo = null;
    }

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

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

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

    return shoppingAPI.orderSub(uid, addressId, cartType, deliveryTime,
        deliveryWay, invoices, paymentId, paymentType,
        remark, couponCode, yohoCoin, skuList, qhyUnio,
        userAgent, times, activityInfo, ip, isWechat).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 = uid => {
    let result = {
        notAvailableCoupons: [],
        coupons: []
    };

    return shoppingAPI.listCoupon(uid)
        .then(coupons => {
            let unusableCoupons = _.get(coupons, 'data.unusable_coupons', []);
            let usableCoupons = _.get(coupons, 'data.usable_coupons', []);

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

            result.notAvailableCoupons = unusableCoupons.map(procCouponsData);
            result.coupons = usableCoupons.map(procCouponsData);

            return result;
        },
            () => result
        );
};

exports.searchCoupon = (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,
            cartType,
            deliveryId,
            paymentType,
            couponCode,
            yohoCoin,
            skuList
        ).then(result => {
            return paymentProcess.transformJit(_.get(result, 'data.package_list', []));
        });
    } else {
        return shoppingAPI.cartPayAPI(
            uid,
            cartType,
            0,
            skuList
        ).then(result => {
            return paymentProcess.transformJit(_.get(result, 'data.shopping_cart_data.package_list', []));
        });
    }
};