/**
 * 商品详情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 Fn = require('lodash/fp');
const cheerio = require('cheerio');
const url = require('url');
const helpers = global.yoho.helpers;
const config = global.yoho.config;
const crypto = global.yoho.crypto;

const videoPlayerTpl = require('../helper/video-player-tpl');

const productAPI = require('./detail-product-api');
const detailHelper = require('./detail-helper');

const consultService = require('./detail-consult-service');
const commentService = require('./detail-comment-service');
const hotAreaService = require('./detail-hotarea-service');
const couponService = require('./coupon-service');
const brandService = require('./brand-service');
const favoriteProductService = require('./favorite-product-service');
const shopService = require('./shop-service');

const searchAPI = require('./search-api');
const homeService = require('./home-service');
const HeaderModel = require('../../../doraemon/models/header');

const BLANK_STR = ' ';
const BUNDLE_PRODUCE = 2; // 量贩
const BUNDLE_PACKAGE = 1; // 套餐

// 展览票
const YOHOOD_TICKET = 51335912;

const _getProductAdditionInfoAsync = (data) => {
    return co(function * () {
        let productId = _.get(data, 'product_id', 0);
        let brandId = _.get(data, 'brand_info.brand_id', 0);

        // 获取相关数据
        let promiseData = {
            productBanner: productAPI.getProductBannerAsync(productId),
            bannerInfo: brandService.getBannerInfoAsync(brandId)
        };

        let result = yield Promise.props(promiseData);

        return result;
    })();
};

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

        return result;
    })();
};

/**
 * 获取商品的喜欢
 * pid : product id
 * bid : brand id
 */
const _getProductFavoriteDataAsync = (uid, pid) => {
    return co(function*() {
        let result = {
            product: false,
            brand: false
        };

        if (!uid) {
            return result;
        }

        let requestApi = {};

        if (pid) {
            requestApi.product = favoriteProductService.isFavoriteAsync(uid, pid);
        }

        let requestData = yield Promise.props(requestApi);

        let productData = requestData.product;

        if (productData) {
            result.product = productData.code === 200 && productData.data ? true : false;
        }

        return result;
    })();
};

// 商品标签
const _getTagsDataByProductInfo = (data) => {
    let tags = [];

    _.get(data, 'tags', []).forEach((value) => {
        let tag = {};

        switch (value) {
            case 'is_soon_sold_out': // 即将售磬
                tag.isFew = true;
                break;
            case 'is_new': // 新品NEW
                tag.isNew = true;
                break;
            case 'is_discount': // SALE
                tag.isSale = true;
                break;
            case 'is_limited': // 限量
                tag.isLimit = true;
                break;
            case 'is_yohood': // YOHOOD
                tag.isNewFestival = true;
                break;
            case 'is_advance': // 再到着
                tag.isReNew = true;
                break;
            case 'mid_year':// 年中热促
                tag.isYearMidPromotion = true;
                break;
            case 'year_end':// 年终大促
                tag.isYearEndPromotion = true;
                break;
            case 'is_presell':// 预售
                tag.isPresell = true;
                break;
            default:
                break;
        }

        tags.push(tag);
    });

    return tags;
};

// vip 价格
const _getVipDataByProductBaseInfo = (data, vipLevel, uid) => {
    vipLevel = vipLevel || 0;
    uid = uid || 0;

    if (_.isEmpty(_.get(data, 'vip', []))) {
        return null;
    }

    let isVip = (_v) => _v > 0;
    let isLogin = (_u) => _u > 0;
    let isNormalUser = () => isLogin(uid) && !isVip(vipLevel);
    let isVipUser = () => isLogin(uid) && isVip(vipLevel);

    let vipData = {};

    vipData.unLogin = isLogin(uid) ? false : helpers.urlFormat('/signin.html');
    vipData.normalUser = isNormalUser();

    if (isVipUser()) {
        vipData.prices = {};
        _.some(data.vip, (vip) => {
            if (detailHelper.vipLevel(vip.caption + '会员') === vipLevel) {
                vipData.prices = {
                    price: vip.price,
                    name: vip.caption,
                    vipLevel: vipLevel
                };
                return true;
            }
        });
    }

    vipData.vipSchedualUrl = helpers.urlFormat('/home/vip', {
        t: _.random(10000, 9999999)
    });

    return vipData;
};

// 活动
const _getProductActivityBanner = (additionalData) => {
    let data = additionalData.productBanner;

    if (_.isEmpty(data) ||
        _.get(data, 'code', 400) !== 200 ||
        !_.get(data, 'data.bannerImg')) {
        return false;
    }

    return {
        activityImg: helpers.getForceSourceUrl(data.data.bannerImg),
        url: data.data.promotionUrl
    };
};

const _getBundleAsync = (result) => {
    return {
        count: _.get(result, 'data.bundleInfo.bundleCount', 1),
        phrase: _.get(result, 'data.bundleInfo.promotionPhrase', ''),
        type: _.get(result, 'data.bundleInfo.discountType', 1),
        discount: _.get(result, 'data.bundleInfo.discount', null)
    };
};

const _getActivityDataByProductBaseInfo = (data) => {
    return _.get(data, 'data', []).map(value => {
        let des = value.promotionTitle.replace(/￥/g, '¥');

        return {
            type: value.promotionType.replace(/￥/g, '¥'),
            des: des,
            url: value.id && helpers.urlFormat('', {psp_id: value.id, phrase: encodeURIComponent(des)}, 'list')
        };
    });
};

/**
 * 获取品牌数据
 */
const _getBrandDataByProductBaseInfo = (data, additionalData) => {
    if (!_.get(data, 'brand_info')) {
        return {};
    }

    let brandId = data.brand_info.brand_id;
    let logo = '';
    let bannerInfo = null;
    let result = _.get(additionalData, 'bannerInfo', {});

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

    if (_.get(data, 'brand_info.brand_ico')) {
        logo = helpers.getForceSourceUrl(data.brand_info.brand_ico);
    }

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

    // banner的logo
    if (bannerInfo && bannerInfo.logo) {
        logo = helpers.getForceSourceUrl(bannerInfo.logo);
    }

    let homeUrl = 'javascript:void(0)'; // eslint-disable-line no-script-url

    if (_.get(data, 'brand_info.brand_domain')) {
        homeUrl = helpers.urlFormat('', null, data.brand_info.brand_domain);
    }

    // 导航的品牌banner
    return {
        brandId: brandId,
        bgColor: '#000000',
        logo: logo,
        alt: data.brand_info.brand_name,
        brandName: data.brand_info.brand_name,
        brandDomain: data.brand_info.brand_domain,
        homeUrl: homeUrl
    };
};

/**
 * 获得sku商品数据
 */
const _getSkuDataByProductBaseInfo = (data) => {
    let totalStorageNum = 0;
    let skuGoods = null;// sku商品
    let defaultImage = '';// 默认图
    let defaultSkuFlag = false; // 选中状态
    let marketPrice = _.get(data, 'market_price', 0.0);

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

    skuGoods = _.get(data, 'goods_list', []).reduce((goodsDetailList, goods)=> {

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

        if (_.isEmpty(goods.color_image)) {
            return goodsDetailList;
        }

        if (goods.images_list) {
            // 商品列表
            goodsDetail.productSkc = goods.product_skc;
            goodsDetail.src = goods.color_image;
            goodsDetail.title = `${_.trim(data.product_name)} ${goods.factory_goods_name}`;
            goodsDetail.name = goods.factory_goods_name;
            goodsDetail.focus = false;
            goodsDetail.total = 0;
            goodsDetail.thumbs = [];
            goodsDetail.size = [];

            if (goodsDetail.title.length > 20) {
                goodsDetail.title = goodsDetail.title.substr(0, 20) + '...';
            }
        }

        _.get(goods, 'images_list', []).forEach((good) => {
            if (good.image_url) {
                goodsDetail.thumbs.push({
                    url: '',
                    shower: good.image_url,
                    img: good.image_url
                });
            }
        });

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

        // 商品的尺码列表
        _.get(goods, 'size_list', []).forEach((size) => {
            if (data.attribute === 3) {
                // 虚拟商品,门票默认最大为4,
                size.storage_number = size.storage_number > 4 ? 4 : size.storage_number;
            } else {
                // 将（价格 > 500）并且（库存 > 5） 将库存变成 5 ，这里是为了防爬虫
                size.storage_number = marketPrice > 500.0 && size.storage_number > 5 ? 5 : size.storage_number;
            }

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

            // 是否显示到货通知
            size.notify = size.isSuppled === 'Y' && size.storage_number === 0 ? 'Y' : 'N';

            // 尺码信息
            goodsDetail.size.push({
                name: size.size_name,
                sku: size.product_sku,
                num: _.parseInt(size.storage_number),
                goodsId: size.size_id,
                notify: size.notify,
                soldOut: _.parseInt(size.storage_number) === 0,
                info: _.get(size, 'size_info', '').replace(/\//ig, '-').replace(/ /ig, '／').replace(/:/ig, ' ')
            });

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

            if (goodsDetail.total > 0 && !defaultSkuFlag) { // 默认选中该sku商品
                goodsDetail.focus = true;
                defaultImage = goodsDetail.src; // 默认为选中的skc
                defaultSkuFlag = true;// 选中sku商品
            }

            goodsDetail.disable = !goodsDetail.total > 0;

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

        });

        if (goodsDetail.focus) {
            _.some(goodsDetail.size, function(value) {
                if (value.num !== 0) {
                    value.focus = true;
                    return true;
                }
                return false;
            });
        }

        goodsDetailList.push(goodsDetail);
        return goodsDetailList;
    }, []);

    if (!_.isEmpty(skuGoods) && !defaultSkuFlag) { // 没有选中一个sku商品，默认选中第一个sku商品
        // 所有商品都售罄
        _.head(skuGoods).focus = true;
        defaultImage = _.head(skuGoods).src;
    }

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

/**
 * 处理限购商品的有关按钮状态（或取现购买以及底部商品购买按钮）
 *
 * @param int $uid
 * @param int $showStatus 限购商品的关联状态
 * @param boolean $isBeginSale 限购商品是否已开售
 */
const _getFashionTopGoodsStatus = (uid, showStatus, isBeginSale) => {
    // 潮流尖货状态
    // getLimitedCode //限购码状态
    // hadLimitedCode //是否已经获取限购码
    // limitedCodeSoldOut //限购码是否已经抢光
    // openSoon//即将开售
    // dis //失效
    // buyNow  //是否立即购买
    let result = {
        getLimitedCode: false,
        hadLimitedCode: false,
        limitedCodeSoldOut: false,
        openSoon: false,
        dis: false,
        buyNow: false,
        soldOut: false,
        getLimitedCodeDis: false
    };

    // 显示获取限购码按钮
    switch (showStatus) {
        case 1: // 开售前/后，立即分享获得限购码（用户未领取限购码）
            if (isBeginSale) {
                result.buyNow = true;
                result.dis = true;
            } else {
                result.openSoon = true;
            }
            result.getLimitedCode = true;
            break;
        case 2: // 开售后，限购码已抢光（用户未领取限购码）
            result.buyNow = true;
            result.dis = true;
            result.limitedCodeSoldOut = true;
            break;
        case 3: // 开售后，商品已经售罄
            result.soldOut = true;
            break;
        case 4:// 开售后，立即购买（用户已领取限购码）
            result.buyNow = true;
            result.hadLimitedCode = true;
            if (uid) { // 限购码失效
                result.getLimitedCodeDis = true;
            }
            break;
        case 5: // 开售前，限购码已被抢光（用户未领取限购码）
            result.openSoon = true;
            result.limitedCodeSoldOut = true;
            break;
        case 6: // 开售前，即将开售（用户已领取限购码）
            result.openSoon = true;
            result.hadLimitedCode = true;
            if (uid) { // 限购码失效
                result.getLimitedCodeDis = true;
            }
            break;
        case 7: // 开售后，用户已经用获得的限购码购买过商品
            result.buyNow = true;
            result.dis = true;
            result.hadLimitedCode = true;
            if (uid) { // 限购码失效
                result.getLimitedCodeDis = true;
            }
            break;
        default:
            break;
    }
    return result;
};

/**
 * 获取分类导航列表
 */
function _getSortNavAsync(smallSortId, gender) {
    return co(function*() {
        let data = yield searchAPI.getSortByConditionAsync({sort: smallSortId});

        if (_.isEmpty(data)) {
            return [];
        }

        let navs = [];
        let sort = _.get(data, 'data.sort[0]', {});

        // 一级分类
        navs.push({
            href: helpers.urlFormat('', {msort: sort.sort_id, gender: gender}, 'list'),
            name: sort.sort_name,
            pathTitle: sort.sort_name
        });

        if (sort.sub) {
            // 二级分类
            let subSort = _.head(sort.sub) || {};

            navs.push({
                href: helpers.urlFormat('', {msort: sort.sort_id, misort: subSort.sort_id, gender: gender}, 'list'),
                name: subSort.sort_name,
                pathTitle: subSort.sort_name
            });
        }

        return navs;
    })();
}

// 保存在 gids 和 skns ,最近流览功能
const saveRecentGoodInCookies = (oldSkns, res, addSkns) => {
    oldSkns = oldSkns ? oldSkns.split(',') : [];
    oldSkns = _.reject(oldSkns, old => old === String(addSkns) ? true : false);
    oldSkns.unshift(addSkns);

    res.cookie('_browseskn', _.take(oldSkns, 30).join(','), {
        maxAge: 2000000000,
        domain: config.cookieDomain
    });
};

/**
 * 获取商品的舒适度
 */
const _getProductComfort = (data) => {
    let comfort = data.productComfort;

    if (_.isEmpty(comfort) || !comfort || !comfort.data) {
        return [];
    }

    return _.get(comfort, 'data', []).reduce((all, value) => {
        let blocks = [];
        let flag = false;

        _.range(1, 6).forEach(i => {
            if (i === _.get(value, 'wearSense.value')) {
                flag = true;
                blocks.push({
                    cur: true
                });
            } else {
                blocks.push({});
            }
        });

        // 不存在
        if (!flag) {
            return all;
        }

        // 存在，添加
        all.push({
            name: value.caption.caption,
            minDes: value.caption.low,
            blocks: blocks,
            maxDes: value.caption.high
        });

        return all;
    }, []);
};

/**
 * 基础商品描述
 */
const _getBasicDescription = (productDescBo) => {
    let sex = (function(gender) {
        if (gender === 1) {
            return '男款';
        } else if (gender === 2) {
            return '女款';
        } else {
            return '通用';
        }
    }(productDescBo.gender));

    const basic = [{
        key: '编号',
        value: productDescBo.erpProductId
    }, {
        key: '颜色',
        value: productDescBo.factoryGoodsName,
        dColor: true
    }, {
        key: '性别',
        value: sex
    }];

    return _.get(productDescBo, 'standardBos', []).reduce((all, value) => {
        all.push({
            key: value.standardName,
            value: value.standardVal
        });

        return all;
    }, basic);
};

/**
 * 获得描述数据
 */
const _getDescriptionDataBySizeInfo = (sizeInfo, additionalData) => {
    if (!sizeInfo.productDescBo || !sizeInfo.productDescBo.erpProductId) {
        return false;
    }

    return {
        basic: _getBasicDescription(sizeInfo.productDescBo),
        comfort: _getProductComfort(additionalData)
    };
};

/**
 * 使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', BLANK_STR));
        });

        // 尺码信息
        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 productId
 */
const _getProductModelCard = (sortId, sizeInfo) => {
    if (!sortId || !_.includes([1, 3, 4], sortId)) {
        return [];
    }

    const modelData = _.get(sizeInfo, 'modelCardsBo', []);

    if (_.isEmpty(modelData)) {
        return [];
    }

    const TYPE_SORT = {
        1: ['height', 'weight', 'shoulderWidth', 'bust', 'waist', 'dressSize'],    // 上衣
        3: ['height', 'weight', 'waist', 'hip', 'downDressSize'], // 裤子
        4: ['height', 'weight', 'waist', 'hip', 'downDressSize']  // 裙子
    };

    const local_ = {
        height: ['身高', 'cm'],
        weight: ['体重', 'kg'],
        shoulderWidth: ['肩宽', 'cm'],
        bust: ['胸围', 'cm'],
        waist: ['腰围', 'cm'],
        dressSize: ['日常尺码', ''],
        downDressSize: ['日常尺码', ''],
        hip: ['臀围', 'cm']
    };

    return _.map(modelData, (model) => {
        return {
            avatar: _.get(model, 'avatar'),
            name: _.get(model, 'modelName'),
            size: _.get(model, 'size'),
            desc: _.reduce(TYPE_SORT[sortId], (total, value) => {
                if (model[value]) {
                    total.push({
                        key: local_[value][0],
                        value: model[value] + local_[value][1]
                    });
                }

                return total;
            }, [])
        };
    });
};

/**
 *  获取模特数据
 * @param sizeInfo
 */
const getReferenceDataBySizeInfo = (sizeInfo) => {
    if (_.isEmpty(sizeInfo.modelBos)) {
        return false;
    }

    // 模特试穿, 竖着输出排列显示
    // 模特信息
    let reference = {
        thead: [
            {name: ''},
            {name: '模特', modelCol: true},
            {name: '身高'},
            {name: '体重'},
            {name: '三围'},
            {name: '吊牌尺码'},
            {name: '试穿描述'}
        ],
        tbody: []
    };

    // 模特数据

    sizeInfo.modelBos.forEach((value) => {
        let modelValue = [
            helpers.getForceSourceUrl(value.avatar),
            value.modelName,
            value.height,
            value.weight,
            value.vitalStatistics,
            value.fitModelBo.fit_size,
            value.fitModelBo.feel
        ];

        // 是否有备注
        if (_.get(value, 'fitModelBo.fit_remark')) {
            modelValue.push(value.fitModelBo.fit_remark);
            reference.thead[7] = {name: '备注', remarkCol: true};
        }

        reference.tbody.push(modelValue);
    });

    return reference;
};

/**
 * 获取洗涤材质
 * @param sizeInfo
 */
const _getMaterialDataBySizeInfo = (sizeInfo) => {
    // 洗涤提示
    // 商品材质[洗涤说明]
    return {
        wash: _.get(sizeInfo, 'washTipsList', []).map((value) => ({
            name: value.caption,
            img: value.img
        })),
        materialDetail: _.get(sizeInfo, 'productMaterialList', []).map((value) => ({
            img: value.imageUrl,
            name: value.caption,
            enName: value.encaption,
            text: value.remark
        }))
    };
};

/**
 * 获取商品详情页介绍
 * @param sizeInfo
 */
const _getDetailDataBySizeInfo = (sizeInfo) => {
    let details = '';

    // 详情文字
    if (_.has(sizeInfo, 'productDescBo.phrase')) {
        details += `<em class='details-word'>${sizeInfo.productDescBo.phrase}</em><br/>`;
    }

    // 图片换成懒加载方式
    const replacePairs = {
        '<img src=': '<img class="lazy img-responsive" width="720" height="200" ' +
        'src="data:image/gif;base64,R0lGODlhAQABAJEAAAAAAP///93d3f///yH5BAEAAAMALAAAAAABAAEAAAICVAEAOw==" ' +
        'data-original=',
        '<img border="0" src=': '<img border="0" class="lazy img-responsive" width="720" height="200" ' +
        'src="data:image/gif;base64,R0lGODlhAQABAJEAAAAAAP///93d3f///yH5BAEAAAMALAAAAAABAAEAAAICVAEAOw==" ' +
        'data-original='
    };

    let intro = _.get(sizeInfo, 'productIntroBo.productIntro', '');

    // 详情配图
    _(replacePairs).forEach((value, key)=> {
        intro = _.replace(intro, new RegExp(key, 'gm'), value);
    });


    // 视频链接处理
    let $ = cheerio.load(intro);

    $('.video-placeholder').each((idx, ele) => {
        let $this = $(ele);
        let videoSrc = $this.find('source').attr('src');
        let $video = $this.find('video');
        let width = $video.attr('width');
        let height = $video.attr('height');

        $this.empty().append(videoPlayerTpl(videoSrc, width, height));
    });

    details += $.html();

    return details;
};

/**
 * 获取模特试穿
 * @param productSkn
 */
const _getProductModelTry = (data) => {
    let result = data.productModelTry;

    if (_.isEmpty(result) || result.code !== 200 || _.isEmpty(result.data)) {
        return false;
    }

    let modelTry = {
        thead: ['模特', '身高', '体重', '三围', '试穿尺码', '试穿描述'],
        tbody: []
    };

    // 显示模特信息
    _.get(result, 'data.modelTryBoList', []).forEach((value) => {
        if (value.modelBo &&
            value.sizeBo &&
            value.modelBo.modelName &&
            value.sizeBo.sizeName) {

            modelTry.tbody.push([
                value.modelBo.modelName,
                value.modelBo.height,
                value.modelBo.weight,
                value.modelBo.vitalStatistics,
                value.sizeBo.sizeName,
                value.tryDesc
            ]);
        }
    });

    if (_.has(result, 'data.modelTryImgBoList')) {
        let tryImg = _.head(result.data.modelTryImgBoList);

        modelTry.frImg = helpers.getForceSourceUrl(_.get(tryImg, 'tryImg', '')) || '';
    }

    return modelTry;
};

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

    let sizeInfo = additionalData.sizeInfo;

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

    let result = {};

    // 描述数据
    result.description = _getDescriptionDataBySizeInfo(sizeInfo, additionalData);

    // 模特卡
    result.modelCards = _getProductModelCard(maxSortId, sizeInfo);

    // 试穿模特
    result.fittingReport = _getProductModelTry(additionalData);

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

    // 模特数据
    result.reference = getReferenceDataBySizeInfo(sizeInfo);

    // 洗涤材质
    result.material = _getMaterialDataBySizeInfo(sizeInfo);

    // 商品详情页介绍
    result.details = _getDetailDataBySizeInfo(sizeInfo);

    return result;
};

/**
 * 获取seo信息
 *
 * @param array $goodsInfo
 * @param array $navs
 * @return array
 */
const _getSeoByGoodsInfo = (goodsInfo, navs) => {
    let title = '';
    let brandName = '';
    let sortName = '';

    goodsInfo = goodsInfo || {};
    navs = navs || [];

    if (goodsInfo.brandName) {
        title = goodsInfo.brandName + ' ';
        brandName = goodsInfo.brandName;
    }

    if (_.get(navs, '[1].name')) {
        sortName = navs[1].name;
        title += navs[1].name + '|';
    }

    title += goodsInfo.name + '正品 | YOHO!BUY 有货';

    let keywords = brandName + sortName + ',' + brandName + '官网专卖店,' + brandName + '官方授权店,' +
        brandName + '正品,' + brandName + '打折,' + brandName + '折扣店,' + brandName + '真品,' + brandName + '代购';

    let description = `YOHO!BUY 有货-${brandName}官方授权店，${goodsInfo.name}图片、报价、介绍。` +
        `YOHO!BUY 有货${brandName}官网专卖店提供${brandName}正品、${brandName}真品、 ${brandName}打折、${brandName}代购等。`;

    let cononicalURL = goodsInfo.productUrl;

    return {
        title: title,
        keywords: keywords.replace(/~+/, ''),
        description: description,
        cononicalURL: cononicalURL
    };
};

// 优惠券
const _getCoupon = (coupons) => {
    if (coupons.code !== 200 || _.isEmpty(_.get(coupons, 'data', []))) {
        return false;
    }

    let couponList = _.get(coupons, 'data', []);

    let pickProp = Fn.pick(['couponName', 'amount', 'couponId', 'acquireStatus', 'rule4ShortName']);
    let encodeId = Fn.update('couponId', (cid) => crypto.encryption(null, cid + ''));
    let replace = Fn.update('rule4ShortName', (r)=> r.replace(/￥/g, '¥'));

    return Fn.map(Fn.pipe(pickProp, encodeId, replace))(couponList);
};

// 预上架商品
const _isPreShelves = (product) => {
    let isUnShelves = _.get(product, 'status', -1) === 0;
    let hasSetShelvesTime = _.get(product, 'advance_shelve_time', -1) > 0;

    return isUnShelves && hasSetShelvesTime;
};

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

        let result = {};

        result.md5 = origin.md5;// 用于前端数据变化的对比

        origin = origin.data;

        if (uid) {
            origin.uid = uid;
        }

        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.shopId = propOrigin('shop_id', 0);
        result.brandId = propOrigin('brand_info.brand_id', '');
        result.brandName = propOrigin('brand_info.brand_name', '');

        result.maxSortId = propOrigin('maxSortId', '');
        result.smallSortId = propOrigin('smallSortId', '');

        result.goCartUrl = helpers.urlFormat('/shopping/cart');

        // 定金预售
        result.deposit = propOrigin('is_deposit_advance', 'N');

        // 秒杀商品
        result.secKill = propOrigin('is_secKill', 'N');

        // 量贩
        result.bundleType = propOrigin('bundle_type', 0);

        let requestApi = {
            addition: _getProductAdditionInfoAsync(origin), // 预处理所有的数据
            fav: _getProductFavoriteDataAsync(uid, result.productId), // 处理收藏喜欢数据
            promotion: productAPI.getPromotionAsync(result.skn), // 打折信息
            coupon: couponService.listAsync(propOrigin('brand_info.brand_id'), result.skn, uid) // 优惠券
        };

        if (propOrigin('isLimitBuy', false) && propOrigin('limitProductCode', '')) {
            result.limitProductCode = propOrigin('limitProductCode');

            requestApi.limited = productAPI.getLimitedProductStatusAsync(
                propOrigin('limitProductCode'),
                uid,
                result.skn
            ); // 限购商品的状态
        }

        if (propOrigin('bundle_type') === BUNDLE_PRODUCE) {
            requestApi.bundle = productAPI.getBundleAsync(result.skn); // 量贩
        }

        let requestData = yield Promise.props(requestApi);

        let additionalData = requestData.addition;
        let favoriteData = requestData.fav;
        let promotionData = requestData.promotion;
        let coupon = requestData.coupon;
        let limitedInfo = requestData.limited;
        let bundle = requestData.bundle;

        // 商品标签
        result.tags = _getTagsDataByProductInfo(origin);

        // 商品促销短语
        result.saleTip = propOrigin('sales_phrase', '');

        // 是否收藏
        result.isCollect = favoriteData.product;

        // 带人民币符号的商品价格
        result.marketPrice = propOrigin('format_market_price');
        result.salePrice = propOrigin('format_sales_price');
        result.hasOtherPrice = true;

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

        if (propOrigin('student_price', '')) {
            // 学生价
            result.studentsPrice = propOrigin('student_price');
        } else {
            // VIP数据
            result.vipPrice = _getVipDataByProductBaseInfo(origin, vipLevel, uid);
        }

        // 计算折扣比例
        let marketPriceNum = propOrigin('market_price', 0);
        let salePriceNum = propOrigin('sales_price', 0);

        if (marketPriceNum && salePriceNum && marketPriceNum !== salePriceNum) {
            result.promotion = ((salePriceNum / marketPriceNum) * 10).toFixed(1);

            // 只显示大于1折小于9折的折扣
            if (result.promotion <= 1.0 || result.promotion >= 9.0) {
                result.promotion = false;
            }
        }

        // 促销活动图片
        result.imageBanner = _getProductActivityBanner(additionalData);

        // 促销活动,虚拟商品无促销
        if (propOrigin('attribute') !== 3) {
            result.activity = _getActivityDataByProductBaseInfo(promotionData);
        }

        // 优惠券
        result.coupon = _getCoupon(coupon);

        // 有货币
        if (!_.includes(['', '0'], propOrigin('yohoCoinNum'))) {
            const C_VALUE = {
                type: '返有货币',
                des: '每件返 ',
                rest: '个 有货币'
            };

            result.activity.push({
                type: C_VALUE.type,
                des: `${C_VALUE.des}${propOrigin('yohoCoinNum')}${C_VALUE.rest}`
            });
        }

        // 上市期
        if (propOrigin('expect_arrival_time')) {
            result.arrivalDate = `${propOrigin('expect_arrival_time')}`;

            if (propOrigin('format_sales_price', '0') !== '0') {
                result.presalePrice = propOrigin('format_sales_price');
                delete result.salePrice;
                result.hasOtherPrice = true;
            } else {
                result.presalePrice = result.marketPrice;
                delete result.marketPrice;
            }

            // 普通预售
            result.presale = 'Y';
        }

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

        result.img = skuData.defaultImage;
        result.colors = skuData.skuGoods;
        let totalStorageNum = skuData.totalStorageNum;

        // 限购商品
        if (limitedInfo && limitedInfo.code === 200 && _.get(limitedInfo, 'data.isLimitBuy', false) === true) {
            // 是否开售
            let isBeginSale = _.get(limitedInfo, 'data.saleStatus', 0) === 1;

            // 限购商品有关的展示状态
            let showStatus = _.get(limitedInfo, 'data.showStatus', 1);

            let fashTopGoods = _getFashionTopGoodsStatus(uid, showStatus, isBeginSale);

            result.fashionTopGoods = {
                getLimitedCode: fashTopGoods.getLimitedCode, // 限购码状态
                hadLimitedCode: fashTopGoods.hadLimitedCode, // 是否已经获取限购码
                limitedCodeSoldOut: fashTopGoods.limitedCodeSoldOut, // 限购码是否已经抢光
                getLimitedCodeDis: fashTopGoods.getLimitedCodeDis // 限购码是否失效
            };

            if (fashTopGoods.soldOut) {
                result.soldOut = fashTopGoods.soldOut;
                totalStorageNum = 0; // 改总数为已售磬
            } else {
                result.openSoon = fashTopGoods.openSoon; // 即将开售
                result.dis = fashTopGoods.dis; // 是否失效
                result.buyNow = fashTopGoods.buyNow; // 是否立即购买
                result.buyNowBase = helpers.urlFormat('/cart/easypay'); // 购买链接
            }

            // 限购商品
            result.limitedsale = 'Y';
        }

        // 非普通商品没有优惠券
        const isSpecialProduct = (pro) => {
            return pro.limitedsale === 'Y' || pro.secKill === 'Y' || pro.deposit === 'Y' || pro.presale === 'Y';
        };

        result.coupon = !isSpecialProduct(result) ? result.coupon : [];

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

        if (virtualGoods) {
            result.virtualGoods = virtualGoods;

            // 是否显示虚拟商品，立即购买按钮
            result.isVirtualBtn = soldOut ? false : true;
        }

        if (!soldOut && !notForSale && !virtualGoods) {
            result.addToCart = true;

            // 立即购买或者即将开售存在
            if (result.buyNow || result.openSoon) {
                delete result.addToCart;
            }
        } else if (notForSale) {
            // 非卖品
            result.notForSale = true;
        } else if (soldOut) {
            // 已售磬
            result.soldOut = true;
            delete result.fashTopGoods;
        }

        // 预上架普通商品
        let isPreShelve = _isPreShelves(origin); // 预上架普通商品

        if (isPreShelve) {
            result.soldOut = false;
            result.buyNow = false;
            result.openSoon = true;
            result.notForSale = false;
            result.addToCart = false;
        }

        // 量贩商品
        if (bundle) {
            result.bundle = _getBundleAsync(bundle);

            result.activity.unshift({
                type: '量贩销售',
                des: result.bundle.phrase
            });

            // 重新判断商品的默认图和选中状态

            const bundleCount = result.bundle.count;

            const isSelling = it => it.num >= bundleCount;

            // 判断是否该商品售罄，需要库存小于最低购买数
            const isBundleSelling = Fn.any(Fn.pipe(Fn.prop('size'), Fn.any(isSelling)));

            // 判断是否尺码有售罄
            const isHandleSize = Fn.each(Fn.pipe(Fn.prop('size'), Fn.each((it) => {
                it.soldOut = !isSelling(it);

                // NOTE: 这一块强制让量贩不支持到货通知
                it.notify = 'N';
            })));

            result.soldOut = !isBundleSelling(result.colors);
            isHandleSize(result.colors);

            // 判断是否有skc没有售罄
            // 如果有：focus= true
            // 左侧大图：result.img 同步修改
            // 取消原来的 focus = false

            const canFocusIndex = Fn.findIndex(Fn.pipe(Fn.prop('size'), Fn.any(isSelling)))(result.colors);
            const focusedIndex = Fn.findIndex(it => it.focus)(result.colors);

            if (canFocusIndex && focusedIndex) {
                result.colors[canFocusIndex].focus = true;
                result.img = result.colors[canFocusIndex].src;

                result.colors[focusedIndex].focus = false;
            }

            // 每一个skc 计算售罄状态
            _.each(result.colors, (color) => {
                color.disable = !Fn.any(isSelling)(color.size);
            });
        } else {
            // 普通商品
            result.bundle = {
                count: 1,
                type: result.bundleType
            };
        }

        // 电子票
        result.isTicket = propOrigin('product_skn') === YOHOOD_TICKET;
        if (virtualGoods && result.isTicket) {
            // 虚拟商品
            result.buyNow = true; // 是否立即购买
            result.buyNowBase = helpers.urlFormat('/ticket', null, 'shopping');
            if (result.salePrice) {
                result.advancePrice = result.salePrice; // 先行价格
                delete result.salePrice;
            }
        }

        // 去掉即将售罄
        if (totalStorageNum || soldOut) {
            // 去掉即将售罄
            _.forEach(result.tags, function(value, key) {
                if (value.isFew) {
                    result.tags[key] = {};
                }
            });
        }

        // 分享相关，产品的链接
        result.weixinUrl = propOrigin('product_url');
        result.shareTitle = result.name;
        result.shareImg = helpers.getForceSourceUrl(result.img);
        result.shareDesc = result.phrase;

        // 统计需要的商品信息
        let statGoodsInfo = {};

        statGoodsInfo.uid = uid;
        statGoodsInfo.skn = propOrigin('product_skn');
        statGoodsInfo.productId = propOrigin('product_id');
        statGoodsInfo.productName = result.name.replace('\'', '’');
        statGoodsInfo.brandName = (result.brandName || '').replace('\'', '’');
        statGoodsInfo.marketPrice = (result.marketPrice ?
                result.marketPrice :
                result.presalePrice).replace('¥', ''); // 数字
        statGoodsInfo.salePrice = (result.salePrice ?
            result.salePrice :
            (result.marketPrice || result.presalePrice)).replace('¥', ''); // 数字
        statGoodsInfo.imageUrl = helpers.getForceSourceUrl(result.img);
        statGoodsInfo.productUrl = 'http:' + helpers.getUrlBySkc(propOrigin('product_id'));
        statGoodsInfo.smallSortId = result.smallSortId;
        statGoodsInfo.soldOut = soldOut ? 1 : 0;

        result.productUrl = statGoodsInfo.productUrl;

        // 商品的品牌信息
        let bandInfo = {};

        if (propOrigin('brand_info', '')) {
            result.brandImg = helpers.image(propOrigin('brand_info.brand_ico', ''), 47, 47);
            result.brandName = propOrigin('brand_info.brand_name', '');
            bandInfo = _getBrandDataByProductBaseInfo(origin, additionalData);
            bandInfo.isCollect = favoriteData.brand;

            if (result.shopId) {
                let shopData = yield Promise.props({
                    bannerImg: shopService.getShopBannerAsync(result.shopId),
                    isShopOpen: shopService.queryShopByBrandIdAsync(result.brandId)
                });

                if (shopData.bannerImg) {
                    bandInfo.bgImg = shopData.bannerImg;
                }

                if (shopData.isShopOpen) {
                    bandInfo.homeUrl = helpers.urlFormat('',
                        {shopId: result.shopId},
                        propOrigin('brand_info.brand_domain')
                    );
                } else {
                    result.shopId = '0';
                }
            }
        }

        // 最近浏览功能 ，限量商品不加入到最近浏览
        if (!_.has(result, 'fashionTopGoods')) {
            cookies && cookies(_.get(result, 'skn', ''));
        }

        return {
            goodsInfo: result,
            banner: _.isEmpty(bandInfo) ? null : bandInfo,
            statGoodsInfo: statGoodsInfo

        };
    })();
};

/**
 * 获得商品价格，活动等数据
 */
const getDetailHeader = (pid, uid, isStudent, vipLevel, dataMd5, cookie) => {
    let currentUserProductInfo = _.partial(_detailDataPkg, _, uid, vipLevel, cookie);

    return productAPI.getProductAsync(pid, uid, isStudent, vipLevel)
        .then(currentUserProductInfo)
        .then((result) => {
            return {
                code: 200,  // 改变数据
                data: result
            };
        });
};

/**
 * 是否支持退换货,true 支持,false 不支持
 */
const saleReturn = (skn) => {
    return productAPI.isSupportReturnedSale(skn)
        .then(result => _.get(result, `data.${skn}`, 'N') === 'N' ? 'Y' : 'N');
};

/**
 * 第一次把售价隐藏，防爬虫的需要
 */
const _removeSalePrice = (productInfo) => {
    delete productInfo.goodsInfo.salePrice;
    delete productInfo.goodsInfo.hasOtherPrice;
    delete productInfo.goodsInfo.promotion;

    return productInfo;
};

/**
 *  获取某一个商品详情主页面
 */
const showMainAsync = (data) => {
    return co(function * () {
        // 获取商品基本信息
        let productData = yield productAPI.getProductAsync(data.pid, data.uid, data.isStudent, data.vipLevel);

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

        let smallSortId = _.get(productData, 'data.smallSortId');
        let maxSortId = _.get(productData, 'data.maxSortId');
        let productId = _.get(productData, 'data.product_id');
        let productSkn = _.get(productData, 'data.product_skn');
        let curUserProduct = _.partial(_detailDataPkg, _, data.uid, data.vipLevel, data.gid, data.saveInCookies);

        let requestData = yield Promise.all([
            _getSortNavAsync(smallSortId, data.gender),    // 面包屑导航
            HeaderModel.requestHeaderData(data.channel),   // 通用头部数据
            _getProductIntroAsync(productId, productSkn),  // 商品详细介绍
            curUserProduct(productData)                    // 商品详细价格
        ]);

        let smallSortNavigator = requestData[0];
        let navigatorHeader = requestData[1];
        let productDescription = requestData[2];
        let productInfo = requestData[3];

        // 拼装数据
        let result = {};

        // 商品价格
        result.productDetailPage = true;
        result.detail = _removeSalePrice(productInfo);

        // 商品介绍
        let intro = _getIntroInfo(productSkn, maxSortId, productDescription);

        result.deatil = Object.assign(result.detail, intro);

        // seo
        result.seo = _getSeoByGoodsInfo(productInfo.goodsInfo, smallSortNavigator);

        // 商品页面统计
        result.statGoodsInfo = Object.assign({fullSortName: smallSortNavigator.map(x => x.name).join('-')},
            productInfo.statGoodsInfo
        );

        // 面包屑导航
        result.detail.pathNav = _.concat(
            homeService.getHomeChannelNav(data.channel),
            smallSortNavigator,
            [{name: _.get(productInfo, 'goodsInfo.name')}]
        );

        // 统计代码中需要新的path
        result.statGoodsInfo.category = _.concat(
            homeService.getHomeChannelNav(data.channel),
            smallSortNavigator
        ).map(n => n.name).join('>');

        // 头部数据
        result.headerData = navigatorHeader.headerData;

        // 咨询和评论
        result.detail.comment = true;
        result.detail.consult = true;

        // 最近浏览，最多5条记录
        result.detail.latestWalk = 5;
        return result;
    })();
};


const recommendAsync = (skn, page, limit) => {
    return co(function * () {
        let recommendData = yield productAPI.getShopRecommendAsync(skn, page, limit);

        if (_.get(recommendData, 'code', 400) !== 200) {
            return {
                code: 200,
                data: {
                    products: []
                }
            };
        }

        const formatPrice = p => `¥${p}`;
        const productUrl = (pid, gid, cn) => helpers.getUrlBySkc(pid, gid, cn);
        const productImageUrl = Fn.pipe(Fn.prop('default_images'), _.partial(helpers.image, _, 280, 382, 2, 70));

        let products = _.get(recommendData, 'data.product_list', []).map((rp) => {
            let salePrice = rp.sales_price;
            let marketPrice = rp.market_price;

            let defaultGoods = _.find(rp.goods_list, {is_default: 'Y'});

            // 无默认商品取商品列表第一个
            if (!defaultGoods) {
                defaultGoods = rp.goods_list[0];
            }

            return {
                market_price: salePrice === marketPrice ? '' : formatPrice(helpers.round(marketPrice, 2)),
                price: formatPrice(helpers.round(salePrice, 2)),
                product_name: rp.product_name,
                url: productUrl(rp.product_id, defaultGoods.goods_id, rp.cn_alphabet),
                pic_url: productImageUrl(rp),
                goods_id: defaultGoods.goods_id
            };
        });

        return {
            code: 200,
            data: {
                products: products
            }
        };
    })();
};


/**
 *  获取套餐
 */
const getPackage = (skn) => {
    const isPackage = (type) => type === BUNDLE_PACKAGE;

    return co(function * () {
        let data = yield productAPI.getBundleAsync(skn);
        let resData = {code: data.code},
            packageList = [];

        if (data.code === 200 && !_.isEmpty(data.data) && isPackage(_.get(data, 'data.bundleInfo.discountType'))) {
            let bundleInfo = data.data.bundleInfo || {};
            let productList = data.data.productList || {};

            resData.data = {
                bundleId: bundleInfo.bundleId,
                salesPrice: bundleInfo.salesPriceStr,
                pkgPrice: bundleInfo.discountPriceStr,
                savePrice: bundleInfo.subPrice
            };
            _.forEach(productList, function(value) {
                // sku商品信息
                let skuData = _getSkuDataByProductBaseInfo(value);

                let pkgData = {
                    skn: value.product_skn,
                    url: helpers.urlFormat(url.parse(value.product_url).pathname, null, 'item'),
                    src: value.default_images,
                    productName: value.product_name,
                    productPrice: value.format_sales_price,
                    colors: skuData.skuGoods
                };

                packageList.push(pkgData);
            });

            resData.data.packageData = packageList;
        } else {
            resData.code = 400;
            resData.message = '没有数据';
        }

        return resData;
    })();
};


module.exports = {
    getShareOrderListAsync: commentService.getShareOrderListAsync, // 获取评论列表
    indexConsultAsync: consultService.indexAsync, // 获取咨询列表
    createConsultAsync: consultService.createAsync, // 添加咨询
    likeAsync: consultService.likeAsync, // 咨询喜欢
    usefulAsync: consultService.usefulAsync, // 咨询有用
    showMainAsync: showMainAsync, // 获取某一个商品详情主页面
    indexHotAreaAsync: hotAreaService.indexAsync, // 获取某一个商品的热区数据
    saveRecentGoodInCookies, // 保存最近的商品
    getDetailHeader,
    saleReturn,
    recommendAsync,
    getPackage
};