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

'use strict';

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

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

const consultService = require('./detail-consult-service');
const commentService = require('./detail-comment-service');
const hotAreaService = require('./detail-hotarea-service');
const brandService = require('./brand-service');
const favoriteBrandService = require('./favorite-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 cachedRequestData = {};

//展览票
const EXHIBITION_TICKET = 51257610;

const _getProductAdditionInfoAsync = (data) => {
    return co(function * () {
        let productId = data.id;
        let uid = data.uid ? data.uid : 0;
        let skn = data.erpProductId;
        let brandId = data.brand.id ? data.brand.id : 0;

        // 获取相关数据
        let promiseData = [
            productAPI.getProductBannerAsync(productId, 'web'),
            productAPI.sizeInfoAsync(skn),
            productAPI.getProductComfortAsync(productId),
            productAPI.getProductModelCardAsync(productId),
            productAPI.getProductModelTryAsync(skn),
            brandService.getBannerInfoAsync(brandId)
        ];

        if (uid) {
            promiseData.push(favoriteBrandService.isFavoriteAsync(uid, productId));
        }

        let result = yield Promise.all(promiseData);

        cachedRequestData['ItemData::getProductBanner'] = result[0];
        cachedRequestData['ItemData::sizeInfo'] = result[1];
        cachedRequestData['ItemData::getProductComfort'] = result[2];
        cachedRequestData['ItemData::getProductModelCard'] = result[3];
        cachedRequestData['ItemData::getProductModelTry'] = result[4];
        cachedRequestData['BrandData::getBannerInfo'] = result[5];
        cachedRequestData['FavoriteData::getUidProductFav'] = result[6];

        return null;
    })();
};

const _getCacheDataByName = (resourceName) => {
    return cachedRequestData[resourceName] || false;
};

/**
 * 获取商品的喜欢
 */
const _getProductFavoriteDataAsync = (uid, pid, bid) => {
    return co(function*() {

        let result = {
            product: false,
            brand: false
        };

        if (uid) {
            if (pid) {
                let productData = _getCacheDataByName('FavoriteData::getUidProductFav');

                if (!productData) {
                    productData = yield favoriteProductService.isFavoriteAsync(uid, pid);
                }
                result.product = productData.code === 200 && productData.data ? true : false;
            }

            if (bid) {
                let brandData = yield favoriteBrandService.isFavoriteAsync(uid, bid);

                result.brand = brandData.code && brandData.code === 200 ? true : false;
            }
        }

        return result;

    })();
};

const _getTagsDataByProductInfo = (data) => {
    let tags = {};

    if (data.productTagBoList) {
        data.productTagBoList.forEach(
            value => {
                switch (value.tagLabel) {
                    case 'is_soon_sold_out': // 即将售磬
                        tags.isFew = true;
                        break;
                    case 'is_new': // 新品NEW
                        tags.isNew = true;
                        break;
                    case 'is_discount': // SALE
                        tags.isSale = true;
                        break;
                    case 'is_limited': // 限量
                        tags.isLimit = true;
                        break;
                    case 'is_yohood': // YOHOOD
                        tags.isNewFestival = true;
                        break;
                    case 'is_advance': // 再到着
                        tags.isReNew = true;
                        break;
                    case 'midYear':// 年中热促
                        tags.isYearMidPromotion = true;
                        break;
                    case 'yearEnd':// 年终大促
                        tags.isYearEndPromotion = true;
                        break;
                }
            }
        );
    }
    return tags;
};

const _getVipDataByProductBaseInfo = (data, vipLevel, uid) => {
    vipLevel = vipLevel || 0;
    uid = uid || 0;

    let vipData = {};

    vipData.prices = [];

    if (data.productPriceBo.vipPrices) {
        if (vipLevel) {
            data.productPriceBo.vipPrices.for(value => {
                vipData.prices.push({
                    level: value.vipLevel,
                    price: value.vipPrice,
                    name: value.vipTitle,
                    cur: value.vipLevel === vipLevel ? true : false
                });
            });
        }

        vipData.unLogin = false;

        if (!uid) {
            vipData.unLogin = helpers.urlFormat('signin.html');
        }

        if (!vipLevel && uid) {
            vipData.normalUser = true;
        }

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

const _getProductActivityBanner = () => {

    let result = {};

    let data = _getCacheDataByName('ItemData::getProductBanner');

    if (!data) {
        return result;
    }

    if (data.code && data.code === 200 && data.data) {
        result.activityImg = helpers.image(data.data.bannerImg, 260, 64);
        result.url = data.data.promotionUrl;
    }

    return result;
};

const _getActivityDataByProductBaseInfo = (data) => {
    let result = [];

    let activityBanner = _getProductActivityBanner();

    if (activityBanner) {
        result.push(activityBanner);
    }

    if (!data.promotionBoList) {
        return result;
    }

    data.promotionBoList.forEach(value => {
        result.push({
            type: value.promotionType,
            des: value.promotionTitle
        });
    });

    return result;
};

/**
 * 获取商品咨询和评论数据
 * @param data
 */
const _getConsultCommentDataByProductInfo = (data) => {

    // 商品咨询
    let consultComment = {};

    consultComment.consultNum = 0;
    consultComment.captchaUrl = helpers.urlFormat('/passport/images', {
        t: moment().unix()
    });

    if (data.consultBoWrapper) {
        consultComment.consults = [];
    }

    // 商品评价
    consultComment.commentNum = 0;
    if (data.commentBoWrapper) {
        consultComment.comments = [];
        consultComment.commentUrl = helpers.urlFormat('/home/commnet');
    }

    return consultComment;
};

/**
 * 获取品牌数据
 */
const _getBrandDataByProductBaseInfo = (data) => {
    if (!data.brand) {
        return {};
    }

    let brandId = data.brand.id;

    let bgImg = '';

    let logo = '';

    let bannerInfo = null;

    let result = _getCacheDataByName('BrandData::getBannerInfo');

    if (!result) {
        return {};
    }

    if (data.brand.brandIco) {
        logo = helpers.getForceSourceUrl(data.brand.brandIco);
    }

    if (result.code && result.code === 200 && result.data) {
        bannerInfo = result.data;
        if (bannerInfo.bannerUrl) {
            bgImg = helpers.getForceSourceUrl(bannerInfo.bannerUrl);
        }
    }

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

    let homeUrl = 'javascript:void(0)';

    if (data.brand.brandDomain) {
        homeUrl = helpers.urlFormat('', {}, data.brand.brandDomain);
    }

    // 导航的品牌banner
    return {
        brandId: brandId,
        bgColor: bannerInfo.colorValue ? bannerInfo.colorValue : '#000000',
        bgImg: bgImg,
        logo: logo,
        alt: data.brand.brandName,
        brandName: data.brand.brandName,
        brandDomain: data.brand.brandDomain,
        homeUrl: homeUrl,
        isCollect: false
    };
};

/**
 * 获得sku商品数据
 */
const _getSkuDataByProductBaseInfo = (data) => {
    let totalStorageNum = 0;

    let skuGoods = null;// sku商品

    let defaultImage = '';// 默认图

    let chooseSkuFlag = false; // 选中状态

    if (data.goodsList) {
        skuGoods = data.goodsList.reduce((acc, cur, pos)=> {

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

            if (_.isUndefined(cur.colorImage)) {
                return acc;
            }

            if (cur.goodsImagesList) {
                // 商品列表
                goodsGroup.productSkc = cur.productSkc;
                goodsGroup.src = helpers.image(cur.colorImage, 40, 40);
                goodsGroup.title = `${_.trim(data.productName)} ${cur.colorName}`;
                goodsGroup.name = cur.colorName;
                goodsGroup.focus = false;
                goodsGroup.total = 0;
                goodsGroup.thumbs = [];
                goodsGroup.size = [];
            }

            cur.goodsImagesList.forEach(good => {
                if (good.imageUrl) {
                    goodsGroup.thumbs.push({
                        url: '',
                        shower: helpers.image(good.imageUrl, 420, 560),
                        img: helpers.image(good.imageUrl, 75, 100)
                    });
                }
            });

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

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

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

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

                goodsGroup.size.push({
                    name: size.sizeName,
                    sku: size.goodsSizeSkuId,
                    num: parseInt(size.goodsSizeStorageNum),
                    goodsId: size.goodsId
                });

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

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

                totalStorageNum += parseInt(size.goodsSizeStorageNum);

            });

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

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

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

/**
 * 处理限购商品的有关按钮状态（或取现购买以及底部商品购买按钮）
 *
 * @param int $uid
 * @param int $showStatus 限购商品的关联状态
 * @param boolean $isBeginSale 限购商品是否已开售
 */
const _getFashionTopGoodsStatus = (uid, showStatus, isBeginSale) => {
    // 潮流尖货状态
    // getLimitedCode //限购码状态
    // hasLimitedCode //是否已经获取限购码
    // limitedCodeSoldOut //限购码是否已经抢光
    // openSoon//即将开售
    // dis //失效
    // buyNow  //是否立即购买
    let result = {
        getLimitedCode: true,
        hasLimitedCode: 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.hasLimitedCode = false;
                }
                break;
            }
        case 2: // 开售后，限购码已抢光（用户未领取限购码）
            {
                result.buyNow = true;
                result.dis = true;
                result.limitedCodeSoldOut = true;
                result.getLimitedCode = false;
                result.hasLimitedCode = false;
                break;
            }
        case 3: // 开售后，商品已经售罄
            {
                result.soldOut = true;
                result.getLimitedCode = false;
                break;
            }
        case 4:// 开售后，立即购买（用户已领取限购码）
            {
                result.buyNow = true;
                result.dis = false;
                result.hasLimitedCode = true;
                if (uid) { // 限购码失效
                    result.getLimitedCodeDis = true;
                }
                break;
            }
        case 5: // 开售前，限购码已被抢光（用户未领取限购码）
            result.openSoon = true;
            result.hasLimitedCode = true;
            result.limitedCodeSoldOut = true;
            result.getLimitedCode = false;
            break;
        case 6: // 开售前，即将开售（用户已领取限购码）
            result.openSoon = true;
            result.hasLimitedCode = true;
            if (uid) { // 限购码失效
                result.getLimitedCodeDis = true;
            }
            break;
        case 7: // 开售后，用户已经用获得的限购码购买过商品
            result.buyNow = true;
            result.dis = true;
            result.hasLimitedCode = true;
            if (uid) { // 限购码失效
                result.getLimitedCodeDis = true;
            }
    }


    return result;
};

/**
 * 获取分类导航列表
 */
function _getSortNavAsync(smallSortId, gender) {
    return co(function*() {

        let navs = [];

        let data = yield searchAPI.getSortByConditionAsync({sort: smallSortId});

        if (data.data) {
            let sort = _.head(data.data.sort);

            // 一级分类
            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;
    })();
}

/**
 * 详情页数据格式化
 * @param origin Object 原始数据
 * @return result Object 格式化数据
 */
const _detailDataPkg = (origin, uid, vipLevel) => {
    return co(function*() {
        let result = {}; // 结果输出

        // 商品名称
        if (!origin.productName) {
            return result;
        }

        origin.uid = uid;
        result.name = origin.productName;
        result.skn = origin.erpProductId;
        result.productId = origin.id;
        result.maxSortId = origin.maxSortId;
        result.smallSortId = origin.smallSortId;
        result.promotionId = origin.isPromotion;
        result.goCartUrl = helpers.urlFormat('shopping/cart');

        let brandId = 0;

        if (origin.brand.id) {
            brandId = origin.brand.id;
        }

        let requestData = yield Promise.all([
            _getProductAdditionInfoAsync(origin), // 接口处理数据，设置并发请求数据
            _getProductFavoriteDataAsync(uid, result.productId, brandId) // 处理收藏喜欢数据
        ]);

        let favoriteData = requestData[1];

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

        //  商品促销短语
        if (origin.salesPhase) {
            result.saleTip = origin.salesPhrase;
        }

        // 商品价格
        if (origin.productPriceBo) {
            result.marketPrice = origin.productPriceBo.formatMarketPrice;
            result.hasOtherPrice = true;
            result.salePrice = origin.productPriceBo.formatSalesPrice;
            if (result.marketPrice === result.salePrice) {
                delete result.salePrice;
                result.hasOtherPrice = false;
            }
        }

        //  VIP数据
        result.vipPrice = _getVipDataByProductBaseInfo(origin, vipLevel, uid);

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

        const C_VALUE = {
            type: '返YOHO币',
            des: '每件返 ',
            rest: '个 YOHO币'
        };

        if (origin.productPriceBo.yohoCoinNum && origin.productPriceBo.yohoCoinNum !== 0) {
            result.activity.push({
                type: C_VALUE.type,
                des: `${C_VALUE.des}${origin.productPriceBo.yohoCoinNum}${C_VALUE.rest}`
            });
        }

        // 上市期
        if (origin.expectArrivalTime) {
            result.arrivalDate = `${origin.expectArrivalTime}月`;
            result.presalePrice = origin.productPriceBo.formatSalesPrice;
            delete result.salePrice;
            result.hasOtherPrice = false;
        }

        // 商品咨询和评论数据，当前为空
        let consultComment = _getConsultCommentDataByProductInfo(origin);

        // 品牌信息
        let banner = null;

        if (origin.brand) {
            result.brandImg = helpers.image(origin.brand.brandIco, 47, 47);
            result.brandName = origin.brand.brandName;
            result.brandUrl = helpers.urlFormat('', {}, origin.brand.brandDomain);
            banner = _getBrandDataByProductBaseInfo(origin);
            if (banner.isCollect && favoriteData.brand) {
                banner.isCollect = favoriteData.brand;
            }
        }

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

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

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

        if (origin.isLimitBuy === 'y') {
            // 是否开售
            let isBeginSale = !!(origin.saleStatus && origin.saleStatus === 1);

            // 限购商品有关的展示状态
            let showStatus = 1;

            if (origin.showStatus) {
                showStatus = parseInt(origin.showStatus);
            }

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

            result.fashTopGoods = {
                getLimitedCode: fashTopGoods.getLimitedCode, // 限购码状态
                hasLimitedCode: fashTopGoods.hasLimitedCode, // 是否已经获取限购码
                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; // 是否立即购买
            }
        }

        let soldOut = !!(origin.status === 0 || totalStorageNum === 0);

        let notForSale = origin.attribute === 2; // 非卖品

        let virtualGoods = origin.attribute === 3; // 虚拟商品

        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;
        } else if (virtualGoods) {
            // 虚拟商品
            result.buyNow = true; // 是否立即购买
            result.buyNowBase = helpers.urlFormat('ticket', {}, 'shopping');
            result.virtualGoods = virtualGoods;
            if (result.salePrice) {
                result.advancePrice = result.salePrice; // 先行价格
                delete result.salePrice;
            }
            //是否展览票
            result.isTicket = origin.erpProductId * 1 === EXHIBITION_TICKET;
        }

        // 去掉即将售罄
        if (totalStorageNum || soldOut) {
            if (result.tags.isFew) {
                delete result.tags.isFew; // 去掉即将售罄
            }
        }

        // 分享相关，产品的链接
        result.weixinUrl = helpers.urlFormat(origin.productUrl, {}, 'item');
        result.shareTitle = result.name;
        result.shareImg = result.img;
        result.shareDesc = result.phrase;

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

        statGoodsInfo.uid = uid;
        statGoodsInfo.skn = origin.erpProductId;
        statGoodsInfo.productId = origin.id;
        statGoodsInfo.productName = result.name.replace('\'', '’');
        statGoodsInfo.brandName = (result.brandName || '').replace('\'', '’');
        statGoodsInfo.marketPrice = result.marketPrice.replace('¥', '');
        if (result.salePrice) {
            statGoodsInfo.salePrice = result.salePrice.replace('¥', '');
        } else {
            statGoodsInfo.salePrice = result.marketPrice.replace('¥', '');
        }

        if (banner.brandId) {
            let domainBrand = yield brandService.getBrandByDomainAsync(banner.brandDomain);

            if (domainBrand.type && domainBrand.shopId) {
                switch (parseInt(domainBrand.type)) {
                    case 1:
                        {
                        // 多品店不显示
                            banner = [];
                            break;
                        }
                    case 2:
                        {
                        // 单品店显示新版的店铺banner
                            let basisData = yield shopService.basisTemplateAsync(domainBrand.shopId);

                            banner.bgImg = basisData.shopTopBanner.banner || banner.bgImg;
                            break;
                        }

                }
            }
        }

        statGoodsInfo.imageUrl = result.img;
        statGoodsInfo.productUrl = result.weixinUrl;
        statGoodsInfo.smallSortId = result.smallSortId;
        statGoodsInfo.soldOut = parseInt(soldOut);

        return {
            goodsInfo: result,
            consultComment: consultComment,
            banner: banner,
            statGoodsInfo: statGoodsInfo
        };
    })();
};

/**
 * 获取商品的舒适度
 */
const _getProductComfort = () => {
    let result = [];
    let comfort = _getCacheDataByName('ItemData::getProductComfort');

    if (!comfort || !comfort.data) {
        return result;
    }

    comfort.data.forEach(value => {
        let blocks = [];
        let flag = false;

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

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

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

    return result;
};

/**
 * 基础商品描述
 */
const _getBasicDescription = (productDescBo) => {
    let sex = '';

    switch (productDescBo.gender) {
        case 1:
            {
                sex = '男款';
                break;
            }
        case 2:
            {
                sex = '女款';
                break;
            }
        default:
            {
                sex = '通用';
            }
    }

    let basic = [];

    basic.push({
        key: '编号',
        value: productDescBo.erpProductId
    });

    basic.push({
        key: '颜色',
        value: productDescBo.colorName,
        dColor: true
    });

    basic.push({
        key: '性别',
        value: sex
    });

    if (!productDescBo.standardBos) {
        return basic;
    }

    productDescBo.standardBos.forEach(value => {
        basic.push({
            key: value.standardName,
            value: value.standardVal
        });
    });

    return basic;
};

/**
 * 获得描述数据
 */
const _getDescriptionDataBySizeInfo = (sizeInfo) => {
    let description = {};

    if (!sizeInfo.productDescBo.erpProductId) {
        return description;
    }

    description.basic = _getBasicDescription(sizeInfo.productDescBo);
    description.comfort = _getProductComfort();

    return description;
};

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

    // TODO: 这里的排序代码很乱

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

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

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


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

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

        sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;

    });

    return sizeInfoBo;
};

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

    // 尺码信息
    if (sizeInfo.sizeInfoBo) {
        sizeInfo.sizeInfoBo = _sizeInfoBoSort(sizeInfo.sizeInfoBo);

        let boyReference = !!sizeInfo.productExtra.boyReference;

        let girlReference = !!sizeInfo.productExtra.girlReference;

        let gender = sizeInfo.productDescBo.gender || 3;

        let referenceName = '参考尺码';

        if ((gender === 1 && boyReference) || (gender === 2 && girlReference)) {
            referenceName = '参考尺码';
        } else if (gender === 3 && boyReference) {
            referenceName = '参考尺码(男)';
        } else if (gender === 3 && girlReference) {
            referenceName = '参考尺码(女)';
        }

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

        if (sizeInfo.sizeInfoBo.sizeAttributeBos) {
            // 尺码信息头部
            size.thead = [{name: '吊牌尺码', id: ''}];

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

            sizeInfo.sizeInfoBo.sizeAttributeBos.forEach(attr => {
                size.thead.push({
                    name: attr.attributeName || ' ',
                    id: attr.id
                });
            });


            size.tbody = [];

            sizeInfo.sizeInfoBo.sizeBoList.forEach(value => {

                let sizes = [];

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

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

                // 其他尺码信息
                value.sortAttributes.forEach(attr => {
                    sizes.push((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 = () => {

    let result = [];

    let data = _getCacheDataByName('ItemData::getProductModelCard');

    if (!data) {
        return result;
    }

    if (data.code && data.code === 200) {
        _(data.data).forEach(val => {
            result.push({
                url: helpers.getForceSourceUrl(val.modelImg),
                size: val.size,
                name: val.modelName
            });
        });
    }

    return result;
};

/**
 *  获取模特数据
 * @param sizeInfo
 */
const getReferenceDataBySizeInfo = (sizeInfo) => {
    let reference = {};

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

        // 模特数据

        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 (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) => {
    let material = {};

    // 洗涤提示
    if (sizeInfo.washTipsBoList) {
        material.wash = [];
        sizeInfo.washTipsBoList.forEach(value => {
            material.wash.push({
                name: value.caption,
                img: value.img
            });
        });
    }

    if (sizeInfo.productMaterialList) {
        // 商品材质[洗涤说明]
        material.materialDetail = [];
        sizeInfo.productMaterialList.forEach(value => {
            material.materialDetail.push({
                img: value.imageUrl,
                name: value.caption,
                enName: value.encaption,
                text: value.remark
            });
        });
    }

    return material;
};

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

    // 详情配图
    if (sizeInfo.productIntroBo.productIntro) {
        if (sizeInfo.productDescBo.phrase) {
            details += `${sizeInfo.productDescBo.phrase}<br/>`;
        }
    }

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

    let intro = sizeInfo.productIntroBo.productIntro;

    _(replacePairs).forEach((value, key)=> {
        intro = _.replace(intro, key, value);
    });

    details += intro;

    return details;
};

/**
 * 获取模特试穿
 * @param productSkn
 */
const _getProductModelTry = () => {
    let modelTry = {};

    let result = _getCacheDataByName('ItemData::getProductModelTry');

    if (!result) {
        return modelTry;
    }

    if (result.code && result.code === 200 && result.data) {
        // 先显示模特信息
        if (result.data.modelTryBoList) {
            modelTry.thead = ['模特', '身高', '体重', '三围', '试穿尺码', '试穿描述'];
            modelTry.tbody = [];

            result.data.modelTryBoList.forEach(val => {
                if (val.modelBo &&
                    val.sizeBo &&
                    val.modelBo.modelName &&
                    val.sizeBo.sizeName) {

                    modelTry.tbody.push([
                        val.modelBo.modelName,
                        val.modelBo.height,
                        val.modelBo.weight,
                        val.modelBo.vitalStatistics,
                        val.sizeBo.sizeName,
                        val.tryDesc
                    ]);
                }
            });
        } else if (result.data.modelTryImgBoList) {
            let tryImg = _.head(result.data.modelTryImgBoList);

            modelTry.frImg = helpers.getForceSourceUrl(tryImg.tryImg);
        }

    }
    return modelTry;
};

/**
 * 根据最大分类ID获取尺寸属性
 * @param maxSortId
 * @param sizeInfoBo
 */
const _getSizeAttrByMaxSortId = (maxSortId, sizeList) => {
    let attributeIds = null;

    // 不同分类，取得属性值不同
    switch (maxSortId) {
        case 1:
        case 2:
            {
                attributeIds = [3, 4];
                break;
            }

        case 3:
            {
                attributeIds = [6, 10];
                break;
            }
        case 6:
            {
                attributeIds = [13];
                break;
            }
        default:
            {
                attributeIds = [];
            }
    }

    let sizeInfos = [];

    let attributeNames = {};

    // 获取属性名称
    sizeList.sizeAttributeBos.forEach(size => {
        attributeNames[size.id] = size.attributeName;
    });

    sizeList.sizeBoList.forEach(size => {
        let sizeValues = [];

        size.sortAttributes.forEach(sort => {
            if (_.includes(attributeIds, sort.id)) {
                if (sort.sizeValue) {
                    sizeValues.push(
                        `${attributeNames[sort.id]} ${sort.sizeValue}cm`
                    );
                }
            }
        });

        // 获取尺寸属性
        if (!_.isEmpty(sizeValues)) {
            sizeInfos[size.sizeName] = sizeValues.join(' / ');
        }
    });

    return sizeInfos;

};

/**
 * 商品尺码信息
 *
 * @param string $productSkn
 * @param int $maxSortId
 * @return array
 */
const _getSizeInfo = (productSkn, maxSortId)=> {
    let result = {};

    if (productSkn) {
        // 并发资源中是否存在数据
        let sizeInfo = _getCacheDataByName('ItemData::sizeInfo');

        if (!sizeInfo) {
            return result;
        }

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

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

        // 试穿模特
        let fittingReport = _getProductModelTry();

        if (!_.isEmpty(fittingReport)) {
            result.fittingReport = fittingReport;
        }

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

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

        if (_.isEmpty(reference)) {
            result.reference = reference;
        }

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

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

        // 获取尺寸说明
        result.sizeTitleJson =
            sizeInfo.sizeInfoBo ? JSON.stringify(_getSizeAttrByMaxSortId(maxSortId, sizeInfo.sizeInfoBo)) : '';
    }

    return result;
};

/**
 *  获取某一个商品详情主页面
 */
const showMainAsync = data => {

    return co(function * () {
        let result = {};
        let currentUserProductInfo = _.curry(_detailDataPkg)(_, data.uid, data.vipLevel);

        // 获取商品信息
        let productInfo = yield productAPI.getProductAsync(data.pid, data.uid).then(currentUserProductInfo);

        let requestData = yield Promise.all([
            _getSortNavAsync(productInfo.goodsInfo.smallSortId, data.gender),
            HeaderModel.requestHeaderData()
        ]);

        // 获取商品尺寸相关
        let sizeInfo = _getSizeInfo(productInfo.goodsInfo, productInfo.goodsInfo.maxSortId);

        // 分类导航
        let navs = requestData[0];

        result.headerData = requestData[1];

        result.productDetailPage = true;
        result.detail = Object.assign(productInfo, sizeInfo);
        result.statGoodsInfo = Object.assign({
            fullSortName: navs.map(x => x.name).join('-')
        },
            productInfo.statGoodsInfo
        );

        // 导航
        result.detail.pathNav = _.concat(
            homeService.getHomeChannelNav(data.channel),
            navs,
            [{name: productInfo.goodsInfo.name}]
        );

        result.detail.lastWalk = 5;
        return result;
    })();
};


module.exports = {
    indexCommentAsync: commentService.indexAsync, // 获取评论列表
    indexConsultAsync: consultService.indexAsync, // 获取咨询列表
    createConsultAsync: consultService.createAsync, // 添加咨询
    showMainAsync: showMainAsync, // 获取某一个商品详情主页面
    indexHotAreaAsync: hotAreaService.indexAsync // 获取某一个商品的热区数据
};