/**
 * 商品详情models
 * @author: xuqi<qi.xu@yoho.cn>
 * @date: 2016/5/6
 */

'use strict';

const Promise = require('bluebird');
const co = Promise.coroutine;
const _ = require('lodash');
const api = global.yoho.API;
const helpers = global.yoho.helpers;

// const md5 = require('md5');

const ERROR_400_MESSAGE = '系统繁忙，请稍候再试！';
const productAPI = require('./product-api');
const cartApi = require('./cart-api');
const chelper = require('./cart-helper');


/**
 * 转换价格
 *
 * @param float|string $price 价格
 * @return float|string 转换之后的价格
 */
const transPrice = (price) => {
    return price ? (price * 1).toFixed(2) : '0.00';
};

const _getProductIntroAsync = (productSkn) => {
    return co(function * () {
        let result = yield Promise.props({
            sizeInfo: productAPI.sizeInfoAsync(productSkn)
        });

        return result;
    })();
};

/**
 * 获得sku商品数据
 */
const _getSkuDataByProductBaseInfo = (data) => {
    let totalStorageNum = 0;
    let skuGoods = null;// sku商品
    let defaultImage = '';// 默认图
    let chooseSkuFlag = false; // 选中状态

    if (_.isEmpty(_.get(data, 'goods_list', []))) {
        return {
            totalStorageNum,
            skuGoods,
            defaultImage
        };
    }

    skuGoods = _.get(data, 'goods_list', []).reduce((acc, cur, pos)=> {

        // 如果status为0，即skc下架时就跳过该商品$value['status'] === 0
        let goodsGroup = {};

        if (_.isEmpty(cur.color_image)) {
            return acc;
        }

        if (cur.images_list) {
            // 商品列表
            goodsGroup.productSkc = cur.product_skc;
            goodsGroup.src = helpers.image(cur.color_image, 25, 35);
            goodsGroup.title = `${_.trim(data.product_name)} ${cur.color_name}`;
            goodsGroup.name = cur.factory_goods_name;
            goodsGroup.focus = false;
            goodsGroup.total = 0;
            goodsGroup.thumbs = [];
            goodsGroup.size = [];
        }

        _.get(cur, 'images_list', []).forEach((good) => {
            if (good.image_url) {
                goodsGroup.thumbs.push({
                    url: '',
                    shower: helpers.image(good.image_url, 420, 560),
                    img: helpers.image(good.image_url, 75, 100)
                });
            }
        });

        // 缩略图空，不显示
        if (_.isEmpty(goodsGroup.thumbs)) {
            return acc;
        }

        // 默认第一张图片
        if (pos === 0) {
            defaultImage = helpers.image(cur.color_image, 420, 560);
        }

        // 商品的尺码列表
        _.get(cur, 'size_list', []).forEach((size) => {
            if (data.attribute === 3) {
                // 虚拟商品,门票默认最大为4,
                size.storage_number = size.storage_number > 4 ? 4 : size.storage_number;
            }

            // 如果status为0，即skc下架时就跳过该商品
            if (cur.status === 0) {
                size.storage_number = 0;
            }

            goodsGroup.size.push({
                name: size.size_name,
                sku: size.product_sku,
                num: _.parseInt(size.storage_number),
                goodsId: size.size_id
            });

            // 单个sku商品的总数
            goodsGroup.total += _.parseInt(size.storage_number);

            if (goodsGroup.total > 0 && !chooseSkuFlag) { // 默认选中该sku商品
                goodsGroup.focus = true;
                chooseSkuFlag = true;// 选中sku商品
            }

            totalStorageNum += _.parseInt(size.storage_number);

        });

        acc.push(goodsGroup);
        return acc;
    }, []);

    if (!_.isEmpty(skuGoods) && !chooseSkuFlag) { // 没有选中一个sku商品，默认选中第一个sku商品
        _.head(skuGoods).focus = true;
    }

    return {
        defaultImage: defaultImage,
        skuGoods: skuGoods,
        totalStorageNum: totalStorageNum
    };
};

/**
 * 使sizeBoList id以 sizeAttributeBos id顺序一样
 * @param sizeInfoBo
 */
const _sizeInfoBoSort = (sizeInfoBo) => {
    if (!sizeInfoBo.sizeBoList || !sizeInfoBo.sizeAttributeBos) {
        return {};
    }

    _.get(sizeInfoBo, 'sizeBoList', []).forEach((sizeBoList, sizek)=> {
        let sortAttr = {};

        sizeBoList.sortAttributes.forEach(sortAttributes => {
            sortAttr[sortAttributes.id] = sortAttributes;
        });

        sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;
    });

    _.get(sizeInfoBo, 'sizeBoList', []).forEach((sizeBoList, sizek)=> {
        let sortAttr = [];

        sizeInfoBo.sizeAttributeBos.forEach(val => {
            if (sizeBoList.sortAttributes[val.id]) {
                sortAttr.push(sizeBoList.sortAttributes[val.id]);
            }
        });

        sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;

    });

    return sizeInfoBo;
};

/**
 * 获取尺寸信息
 * @param sizeInfo
 * @returns {{}}
 */
const _getSizeData = (sizeInfo) => {

    // 尺码信息
    if (!_.has(sizeInfo, 'sizeInfoBo')) {
        return {};
    }

    sizeInfo.sizeInfoBo = _sizeInfoBoSort(sizeInfo.sizeInfoBo);

    let boyReference = _.get(sizeInfo, 'productExtra.boyReference', false);
    let girlReference = _.get(sizeInfo, 'productExtra.girlReference', false);
    let gender = _.get(sizeInfo, 'productDescBo.gender', 3);
    let referenceName = (function() {
        if (gender === 3 && boyReference) {
            return '参考尺码(男)';
        } else if (gender === 3 && girlReference) {
            return '参考尺码(女)';
        } else {
            return '参考尺码';
        }
    }());

    // 判断是否显示参考尺码
    let showReference = (boyReference && _.get(sizeInfo, 'sizeInfoBo.sizeBoList[0].boyReferSize', false)) ||
        (girlReference && _.get(sizeInfo, 'sizeInfoBo.sizeBoList[0].girlReferSize', false));

    if (!_.has(sizeInfo, 'sizeInfoBo.sizeAttributeBos')) {
        return {};
    }

    // 尺码信息头部
    let size = {
        thead: [{name: '吊牌尺码', id: ''}],
        tbody: []
    };

    // 显示参考尺码
    if (showReference) {
        size.thead[1] = {name: referenceName, id: ''};
    }

    _.get(sizeInfo, 'sizeInfoBo.sizeAttributeBos', []).forEach((value) => {
        size.thead.push({
            name: value.attributeName || ' ',
            id: value.id
        });
    });

    _.get(sizeInfo, 'sizeInfoBo.sizeBoList', []).forEach((value) => {
        let sizes = [];

        // 吊牌尺码
        sizes.push(value.sizeName);

        // 判断是否显示参考尺码
        if (boyReference && (gender === 1 || gender === 3) && showReference) {
            sizes.push(_.get(value, 'boyReferSize.referenceName', ' '));
        } else if (girlReference && (gender === 2 || gender === 3) && showReference) {
            sizes.push(_.get(value, 'girlReferSize.referenceName', ' '));
        } else {
            if (size.thead[1] && showReference) {
                size.thead[1] = {};
            }
        }

        // 其他尺码信息
        _.get(value, 'sortAttributes', []).forEach(attr => {
            sizes.push(_.get(attr, 'sizeValue', ' '));
        });

        // 尺码信息
        size.tbody.push(sizes);
    });

    // 参考尺码为空
    if (_.isEmpty(size.thead[1]) && showReference) {
        // 移除这个值
        size.thead.splice(1, 1);
    }

    // 测量方式
    if (sizeInfo.sizeImage) {
        size.sizeImg = sizeInfo.sizeImage;
    }

    return size;
};

/**
 * 商品尺码信息
 *
 * @param productSkn
 * @param maxSortId
 * @return object
 */
const _getIntroInfo = (productSkn, additionalData)=> {
    if (!productSkn) {
        return {};
    }

    let sizeInfo = additionalData.sizeInfo;

    if (_.isEmpty(sizeInfo)) {
        return {};
    }

    let result = {};

    // 尺寸数据
    result.size = _getSizeData(sizeInfo);

    return result;
};

/**
 * 详情页数据格式化
 * @param origin Object 原始数据
 * @return result Object 格式化数据
 */
const _detailDataPkg = (origin) => {
    return co(function*() {
        if (_.isEmpty(origin) || _.isEmpty(origin)) {
            return {};
        }

        let result = {};
        let propOrigin = _.partial(_.get, origin);

        // 商品名称
        if (!propOrigin('product_name')) {
            return result;
        }

        result.name = propOrigin('product_name');
        result.skn = propOrigin('product_skn');
        result.productId = propOrigin('product_id');

        // 商品价格
        result.marketPrice = propOrigin('format_market_price');
        result.salePrice = propOrigin('format_sales_price');
        result.hasOtherPrice = true;

        if (result.salePrice === '0') {
            delete result.salePrice;
            result.hasOtherPrice = false;
        }

        // 上市期
        if (propOrigin('expect_arrival_time')) {
            result.arrivalDate = `${propOrigin('expect_arrival_time')}月`;
            result.presalePrice = propOrigin('format_sales_price');
            delete result.salePrice;
            result.hasOtherPrice = false;
        }

        // sku商品信息
        let skuData = _getSkuDataByProductBaseInfo(origin);

        // 商品购买状态
        let soldOut = !!(propOrigin('status') === 0 || skuData.totalStorageNum === 0);
        let virtualGoods = propOrigin('attribute') === 3; // 虚拟商品

        if (!soldOut && !virtualGoods) {
            result.addToCart = 1;
        }

        result.isCollect = propOrigin('is_collect');
        result.colors = skuData.skuGoods;

        return result;
    })();
};

/**
 *  获取某一个商品详情主页面
 */
const getProductInfoAsync = (pid) => {
    return co(function * () {
        if (!pid) {
            return {};
        }

        // 获取商品基本信息
        let productData = yield productAPI.getProductAsync(pid);

        if (_.isEmpty(productData.data)) {
            return Promise.reject({
                code: 404,
                message: 'app.product.data api wrong'
            });
        }

        let productSkn = _.get(productData, 'data.product_skn');
        let requestData = yield Promise.all([
            _getProductIntroAsync(productSkn),  // 商品详细介绍
            _detailDataPkg(productData.data)               // 商品详细价格
        ]);

        let productDescription = requestData[0];
        let productInfo = requestData[1];
        let intro = _getIntroInfo(productSkn, productDescription);

        return Object.assign(productInfo, intro);
    })();
};

// 获取优惠券列表
const getCoupons = (uid) => api.get('', {
    method: 'app.Shopping.listCoupon',
    uid: uid
}).then(result => {

    if (result.code === 200) {
        let unuse = [];
        let use = [];

        _.get(result, 'data.unusable_coupons', []).forEach(i => {
            unuse.push({
                code: i.coupon_code,
                name: i.coupon_name,
                value: i.coupon_value,
                canuse: false
            });
        });

        _.get(result, 'data.usable_coupons', []).forEach(i => {
            use.push({
                code: i.coupon_code,
                name: i.coupon_name,
                value: i.coupon_value
            });
        });

        result.data = _.concat(use, unuse);
    }

    return result;
});

/**
 * 购物车数据
 * @param uid
 * @param shoppingKey
 * @param cartDelList
 * @returns {*}
 */
const getCartData = (uid, shoppingKey, cartDelList) => {
    return cartApi.cartData(uid, shoppingKey).then(cartDataRet => {
        return chelper.formatCart(cartDataRet, uid, shoppingKey, cartDelList);
    });
};

/**
 * 获取购物车总数
 *
 * @param int $uid 用户ID
 * @param string $shoppingKey 客户端购物标识
 * @return array
 */
const getCartCount = (uid, shoppingKey) => {
    return cartApi.cartCount(uid, shoppingKey);
};

/**
 * 加入购物车 获取数量
 *
 * @param int $productSku 商品SKU
 * @param int $buyNumber 购买数量
 * @param int $goodsType 商品类型，0表示普通商品，1表示加价购商品
 * @param int $isEdit 是否是编辑商品SKU，0表示不是编辑
 * @param null|int $promotionId 促销id，默认null（加价购有关）
 * @param null|int $uid 用户UID，可以不传
 * @param string $shoppingKey 购物车在浏览器的唯一识别码，可以不传
 * @return array 加入购物车接口返回的数据
 */
const addCart = (productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!productSku) {
            return result;
        }

        let ret = yield cartApi.addToCart(productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey);

        if (ret && ret.code) {
            result = ret;
        }

        return result;
    })();
};

/**
 * 加入购物车
 *
 * @param int $productSku 商品SKU
 * @param int $buyNumber 购买数量
 * @param int $goodsType 商品类型，0表示普通商品，1表示加价购商品
 * @param int $isEdit 是否是编辑商品SKU，0表示不是编辑
 * @param null|int $promotionId 促销id，默认null（加价购有关）
 * @param null|int $uid 用户UID，可以不传
 * @param string $shoppingKey 购物车在浏览器的唯一识别码，可以不传
 * @return array 加入购物车接口返回的数据
 */
const addToCart = (productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!productSku) {
            return result;
        }

        let ret = yield cartApi.addToCart(productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: yield getCartData(uid, shoppingKey || _.get(ret, 'data.shopping_key'), cartDelList)
            };
        }

        if (!shoppingKey && result.data) {
            result.data.shopping_key = _.get(ret, 'data.shopping_key');
        }

        /* if (empty($addCart) || (isset($addCart['code']) && $addCart['code'] !== 200) ) {
         UdpLog::info('【购物车】校验参数传递auth','productSku:'.$productSku.'buyNumber:'.$buyNumber.
         'goodsType:'.$goodsType,'isEdit:'.$isEdit.'promotionId:'.$promotionId.'uid:'.$uid.'shoppingKey:'.$shoppingKey);
         }*/

        return result;
    })();
};

/**
 * 购物车商品选择与取消接口返回的数据处理
 *
 * @param int $uid 用户ID
 * @param string $skuList 商品sku列表json格式, 如{"744403":1}
 * @param string $shoppingKey 未登录用户唯一识别码
 * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
 * @return array 处理之后的数据的数据
 */
const selectGoods = (uid, skuList, shoppingKey, hasPromotion, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!skuList) {
            // UdpLog::info('【购物车】校验参数传递auth', 'skuList:' . $skuList);
            return result;
        }

        let select = yield cartApi.selectGoods(uid, skuList, shoppingKey, hasPromotion);

        if (select && select.code) {
            result = {
                code: select.code,
                data: chelper.formatCart(select, uid, shoppingKey, cartDelList)
            };

            // result = select;
        }/* else {
         UdpLog::info('【购物车】校验参数传递auth', 'uid:' . $uid . 'skuList:'
         . $skuList . 'shoppingKey:' . $shoppingKey . 'hasPromotion:' . $hasPromotion);
         }*/

        return result;
    })();
};

/**
 * 修改购物车商品数量
 *
 * @param int $uid 用户ID
 * @param string $sku 商品SKU
 * @param int $increaseNum 增加的数目
 * @param int $decreaseNum 减少的数目
 * @param string $shoppingKey 未登录用户唯一识别码
 * @return array 接口返回的数据
 */
const modifyProductNum = (uid, sku, increaseNum, decreaseNum, shoppingKey, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!sku) {
            // UdpLog::info('【购物车】校验参数传递auth', 'sku:' . $sku);
            return result;
        }

        let ret = yield cartApi.modifyProductNum(uid, sku, increaseNum, decreaseNum, shoppingKey);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: yield getCartData(uid, shoppingKey, cartDelList)
            };
        }/* else {
         UdpLog::info('【购物车】校验参数传递auth', 'uid:' . $uid . 'sku:' . $sku, 'increaseNum:'
         . $increaseNum . 'decreaseNum:' . $decreaseNum . 'shoppingKey:' . $shoppingKey);
         }*/

        return result;
    })();

};

/**
 * 移出购物车
 *
 * @param int $uid 用户ID
 * @param string $skuList 商品sku列表json格式, 如{"744403":1}
 * @param string $count 要删除的数目
 * @param string $shoppingKey 未登录用户唯一识别码
 * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
 * @return array 接口返回的数据
 */
const removeFromCart = (uid, shoppingKey, skuList, hasPromotion, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!skuList) {
            // UdpLog::info('【购物车】校验参数传递auth', 'skuList:' . $skuList);
            return result;
        }

        let ret = yield cartApi.removeFromCart(uid, shoppingKey, skuList, hasPromotion);

        if (!hasPromotion) {
            return ret;
        }

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: chelper.formatCart(ret, uid, shoppingKey, cartDelList)
            };
        }/* else {
         UdpLog::info('【购物车】校验参数传递auth', 'uid:' . $uid . 'skuList:' .
          $skuList . 'shoppingKey:' . $shoppingKey . 'hasPromotion:' . $hasPromotion);
         }*/

        return result;
    })();
};

/**
 * 移入收藏夹
 *
 * @param int $uid 用户ID
 * @param string $skuList 商品sku列表
 * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
 * @return array 接口返回的数据
 */
const addToFav = (uid, skuList, hasPromotion, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!uid) {
            return {
                code: 403,
                message: '请先登录！',
                data: {
                    url: helpers.urlFormat('/signin.html', {
                        refer: helpers.urlFormat('/cart/cart')
                    })
                }
            };
        }

        if (!skuList) {
            // UdpLog::info('【购物车】校验参数传递auth', 'skuList:' . $skuList);
            return result;
        }

        let ret = yield cartApi.addToFav(uid, skuList, hasPromotion);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: chelper.formatCart(ret, uid, null, cartDelList)
            };
        }/* else {
         UdpLog::info('【购物车】校验参数传递auth', 'uid:' . $uid . 'skuList:' . $skuList . 'hasPromotion:' . $hasPromotion);
         }*/

        return result;
    })();

};

/**
 * 检查用户是否收藏这一批商品
 *
 * @param int $uid 用户ID
 * @param array $skuList 商品SKU列表
 * @return array
 */
const checkUserIsFav = (uid, skuList) => {

    return co(function * () {
        let result = {};

        if (!skuList) {
            return result;
        }

        if (!uid || !_.isNumber(uid)) {

            _.forEach(skuList, it => {
                result[it] = false;
            });

            return result;
        }

        return cartApi.checkUserIsFavProductList(uid, skuList);
    })();
};

/**
 * 获取为你优选商品 待处理
 *
 * @param $channel 频道
 * @param $uid 用户id
 * @param $udid 设备id
 * @param int $page 分页页码
 * @return array
 * @internal param $rec_pos
 * @internal param $limit
 */
const getRecommendProduct = (channelNum, uid, udid, page) => {

    return co(function * () {

        let result = {
            code: 200,
            message: '',
            data: {
                header: '为您优选',
                hasPrev: false,
                hasNext: false,
                item: null
            }
        };

        if (!_.isNumber(page)) {
            return result;
        }

        let together = yield cartApi.newPreference(channelNum, uid, udid, '100003', 30);
        let plist = _.get(together, 'data.product_list');

        if (!plist || !plist.length) {
            return result;
        }

        if (page > 5) {
            page = 1;
        }

        let begin = (page - 1) * 6;
        let end = begin + 7;
        let items = _.map(_.slice(plist, begin, end), it => {

            let item = {
                id: it.product_id,
                skn: it.product_skn,
                title: it.product_name,
                img: it.default_images ? helpers.image(it.default_images, 190, 250) : '',
                alt: it.product_name,
                price: '¥' + chelper.transPrice(it.sales_price),
                marketPrice: (it.market_price && +it.market_price > +it.sales_price) ?
                            '¥' + chelper.transPrice(it.market_price) : ''
            };

            item.href = helpers.getUrlBySkc(it.product_skn);

            if (+it.sales_price !== +it.market_price) {
                it.marketPrice = chelper.transPrice(it.market_price);
            }
            return item;
        });

        Object.assign(result.data, {
            item: items
        });

        return result;
    })();
};

/**
 * 获取凑单商品
 *
 * @param int $page 分页页码
 * @return array
 */
const getTogetherProduct = (page) => {

    return co(function * () {
        let result = {
            code: 200,
            message: '',
            data: {
                header: '凑单商品',
                hasPrev: false,
                hasNext: false,
                item: null
            }
        };

        if (!_.isNumber(page)) {
            return result;
        }

        let together = yield cartApi.togetherProduct(page);

        if (!_.get(together, 'data.goods')) {
            return result;
        }

        result.data.hasPrev = true;
        result.data.hasNext = true;

        result.data.item = _.map(together.data.goods, it => {

            let item = {
                id: it.id,
                skn: it.product_skn,

                // it.url,
                href: it.url,
                title: it.product_name,
                img: it.default_pic ? helpers.image(it.default_pic, 100, 100) : '',
                alt: it.product_name,
                price: Number(it.price.sales_price)
            };

            if (item.price !== Number(it.price.market_price)) {
                it.marketPrice = Number(it.price.market_price);
            }

            return item;
        });

        // 当数据量不足6个时，判定为没有下一页
        if (page === 1) {
            result.data.hasPrev = false;
        }

        if (!result.data.item || result.data.item.length < 6) {
            result.data.hasNext = false;
        }

        return result;
    })();
};

/**
 * 修改购物车商品
 * @param param
 * @param uid
 * @param shoppingKey
 * @param cartDelList
 */
const modifyProduct = (param, uid, shoppingKey, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        let ret = yield cartApi.modifyProduct(param);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: yield getCartData(uid, shoppingKey, cartDelList)
            };
        }

        return result;
    })();
};

/**
 * 重选赠品或加价购商品
 * @param uid
 * @param shoppingKey
 * @param promotionId
 * @param newSkn
 * @param newSku
 * @param cartDelList
 */
const swapGift = (uid, shoppingKey, promotionId, newSkn, newSku, cartDelList) => {
    return co(function * () {

        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        let ret = yield cartApi.swapGift(uid, shoppingKey, promotionId, newSkn, newSku);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: yield getCartData(uid, shoppingKey, cartDelList)
            };
        }

        return result;
    })();

};

/**
 * 查询指定优惠下的可选赠品或加价购
 * @param promotionId 优惠ID
 * @param uid
 * @param shoppingKey
 */
const queryUserPromotionGift = (promotionId, uid, shoppingKey) => {

    return co(function * () {
        let promotionGifts = yield cartApi.queryPromotionGift(promotionId);
        let cartDataRet = yield cartApi.cartData(uid, shoppingKey);
        let selectedGift = chelper.formatCartGoods(_.get(cartDataRet, 'data.ordinary_cart_data.goods_list'));
        let currentProduct = null;  // 默认展示第一个商品

        if (promotionGifts && promotionGifts.code === 200) {
            let promotionList = chelper.formatPriceGifts(_.get(promotionGifts, 'data.arrays', []));

            promotionGifts.data = _.get(promotionList, '[0]', {});

            let goodsList = [];
            let checked;

            _.forEach(promotionList, value => {
                if (!value.goodsList || !value.goodsList.length) {
                    return;
                }

                _.forEach(value.goodsList, it => {
                    if (!checked) {
                        checked = true;
                        it.active = true;
                        currentProduct = it;
                        promotionGifts.data.promotionDesc = value.promotionTitle;
                    }

                    Object.assign(it, {
                        isSelected: !!_.find(selectedGift, ['skn', it.skn]),
                        promotionId: value.promotionId,
                        promotionTitle: value.promotionTitle,
                        maxSelectNumber: value.maxSelectNumber
                    });

                    goodsList.push(it);
                });
            });

            promotionGifts.data.goodsList = goodsList;

            // 获取选中商品的数据详情
            if (currentProduct && currentProduct.id) {
                let prodInfo = yield getProductInfoAsync(currentProduct.id);

                // 价格为活动价
                if (prodInfo) {
                    prodInfo.salePrice = '¥' + currentProduct.subjoinPrice;
                }

                promotionGifts.data.productInfo = prodInfo;
            }
        }


        return promotionGifts;
    })();

};

/**
 * 首页mini购物车数据
 * @param uid
 * @param shoppingKey
 */
const getMiniCartData = (uid, shoppingKey) => {

    return co(function * () {
        let cartDataRet = yield cartApi.cartData(uid, shoppingKey);

        if (!cartDataRet || cartDataRet.code !== 200) {
            return null;
        }

        let ret = cartDataRet && cartDataRet.data;
        let advCart = _.get(ret, 'advance_cart_data');
        let comCart = _.get(ret, 'ordinary_cart_data');
        let advGoodsList = _.flatten(_.map(_.get(advCart, 'goods_pool_list'), 'goods_list'));
        let comGoodsList = _.flatten(_.map(_.get(comCart, 'goods_pool_list'), 'goods_list'));
        let comSubs = _.flatten(_.map(_.get(comCart, 'goods_pool_list'), 'sub_pool'));
        let subsGoodsList = _.flatten(_.map(comSubs, 'goods_list'));

        let advOffShe = _.get(advCart, 'off_shelves_goods_list');
        let comOffShe = _.get(comCart, 'off_shelves_goods_list');

        let advSoldOuts = _.get(advCart, 'sold_out_goods_list');
        let comSoldOuts = _.get(comCart, 'sold_out_goods_list');

        let goodsList = _(advGoodsList).concat(comGoodsList, subsGoodsList,
                                                advOffShe, comOffShe,
                                                advSoldOuts, comSoldOuts);

        goodsList = _.filter(goodsList.value(), it => !!it);

        let glist = _.map(goodsList, g => {
            let goods = {
                is_advance: g.is_advance,
                default_img: g.goods_images ? helpers.image(g.goods_images, 46, 62) : '',
                product_name: g.product_name,
                factory_goods_name: g.factory_goods_name,
                size_name: g.size_name,
                show_price: transPrice(g.real_price),
                buy_number: g.buy_number,
                goods_incart_id: g.shopping_cart_id,
                product_sku: g.product_sku,
                promotion_id: g.promotion_id
            };

            goods.product_url = helpers.getUrlBySkc(g.product_skn);
            return goods;
        });

        let advCount = _.get(ret, 'advance_cart_data.shopping_cart_data.goods_count') || 0;
        let comCount = _.get(ret, 'ordinary_cart_data.shopping_cart_data.goods_count') || 0;

        return {
            main_goods: glist,
            total: Number(advCount) + Number(comCount)
        };
    })();
};

// 套餐添加购物车
const addBundleData = (params) => {
    return cartApi.addBundle(params).then(d => { // eslint-disable-line
        return d;
    });
};

// 套餐增减购物车
const bundleNumData = (params, cartDelList) => {

    return co(function * () {
        let result = {
            code: 400,
            message: ERROR_400_MESSAGE
        };

        if (!params.activity_id) {
            return {
                code: 400,
                message: '无效的活动'
            };
        }

        let ret = yield cartApi.bundleNum(params);

        if (ret && ret.code) {
            result = {
                code: ret.code,
                data: yield getCartData(params.uid, params.shopping_key, cartDelList)
            };
        }

        return result;
    })();
};

module.exports = {
    getProductInfoAsync,        /** 获取商品信息 **/
    getCartData,                /** 购物车数据 **/
    getCartCount,               /** 得到购物车数量 **/
    addCart,                    /** 加入到购物车 获取数量 **/
    addToCart,                  /** 加入到购物车 **/
    selectGoods,                /** 选中/取消选中商品 **/
    modifyProductNum,           /** 修改商品数量 **/
    removeFromCart,             /** 从购物车中删除 **/
    addToFav,                   /** 移入收藏 **/
    checkUserIsFav,             /** 判断商品是否已收藏 **/
    getRecommendProduct,        /** 为您优选商品 **/
    getTogetherProduct,         /** 凑单商品 **/
    modifyProduct,              /** 修改购物车商品 **/
    swapGift,                   /** 重选赠品或加价购商品 **/
    queryUserPromotionGift,     /** 查询指定优惠下的可选赠品或加价购 **/
    getCoupons,                 /** 获取优惠券列表 **/
    getMiniCartData,            /** 首页mini购物车数据 **/
    addBundleData,              /** 套餐添加购物车 **/
    bundleNumData              /** 套餐增减购物车 **/
};