/**
 * 商品详情页model
 * @author: yyq<yanqing.yang@yoho.cn>
 * @date: 2016/7/11
 */
'use strict';

const _ = require('lodash');
const helpers = global.yoho.helpers;

/**
 * 获取原图片路径
 * @function _getForceSourceUrl
 * @param { String } url 图片路径
 * @return { String } 原图片路径
 */
const _getForceSourceUrl = (url) => {
    const str = ['?imageView', '?imageMogr2'];

    _.forEach(str, value => {
        url = _.split(url, value, 1)[0];
    });
    url.replace('http:', '');

    return url;
};

/**
 * 使sizeBoList id以 sizeAttributeBos id顺序一样
 * @function _sizeInfoBoSort
 * @param { Object } sizeInfoBo 尺码数据对象
 * @return { Object } 返回正确排序的尺码信息
 */
const _sizeInfoBoSort = sizeInfoBo => {
    if (!sizeInfoBo.sizeBoList || !sizeInfoBo.sizeAttributeBos) {
        return {};
    }

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

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

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

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


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

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

        sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;

    });

    return sizeInfoBo;
};

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

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

    return resData;
};

/**
 * 设置SEO信息
 * @function setSeoInfo
 * @param { Object } goodInfo 商品信息
 * @param { Object } nav 导航菜单信息
 * @return { Object } 商品SEO信息
 */
const setSeoInfo = (goodInfo, nav) => {
    let brandName = _.get(goodInfo, 'brandName', ''),
        sortName = _.get(nav, '[1].name', '');

    return {
        title: `${brandName} ${sortName} | ${goodInfo.name}正品`,
        keywords: `${brandName} ${sortName},${brandName}正品官网专卖店,${brandName}官方授权店,${brandName}正品,` +
            `${brandName}打折,${brandName}折扣店,${brandName}真品,${brandName}代购`,
        description: _.get(goodInfo, 'share.shareDesc', goodInfo.name)
    };
};

/**
 * 处理商品详情面表屑导航
 * @function setPathNav
 * @param { Object } data 商品分类信息
 * @param { string } name 商品名称
 * @return { Object } 面包屑导航数据
 */
const setPathNav = (data, name, channel) => {
    let resData = {};
    let link = channel,
        gender;

    channel = channel || 'men';

    switch (channel) {
        case 'men': // 男
            link = '';
            gender = '1,3';
            break;
        case 'women': // 女
            gender = '2,3';
            break;
        default: // 其它
            gender = '1,2,3';
            break;
    }

    if (!_.isEmpty(data)) {
        let navs = [{
            link: helpers.urlFormat(`/${link}`),
            name: `${_.toUpper(channel)}首页`
        }];
        let sort = _.get(data, 'sort[0]', {});

        if (!_.isEmpty(sort)) {
            navs.push({
                link: helpers.urlFormat('/list', {
                    msort: sort.sort_id,
                    gender: gender
                }),
                name: sort.sort_name,
                pathTitle: sort.sort_name
            });

            // 二级分类
            if (!_.isEmpty(sort.sub)) {
                navs.push({
                    link: helpers.urlFormat('/list', {
                        msort: sort.sort_id,
                        misort: sort.sub.sort_id,
                        gender: gender
                    }),
                    name: sort.sub[0].sort_name,
                    pathTitle: sort.sub[0].sort_name
                });
            }
        }

        navs.push({
            name: name,
            pathTitle: name
        });

        resData.nav = navs;
    }

    return resData;
};

/**
 * 设置品牌banner数据
 * @function setBrandBanner
 * @param { Object } brand 品牌相关数据
 * @return { Object } 品牌banner
 */
const setBrandBanner = (base, brand, shop) => {
    let resData = {},
        banner = {};

    if (base.brand) {
        let info = base.brand;

        // 基础品牌数据
        banner = {
            brandId: info.id,
            bgColor: '#000',
            brandLogo: {
                link: `/product/shop/${info.brandDomain}`, // 品牌跳转链接
                img: info.brandIco
            },
            brandHome: {
                link: `/product/shop/${info.brandDomain}` // 品牌跳转链接
            }
        };

        // 品牌banner数据
        if (brand) {
            if (brand.colorValue) {
                banner.bgColor = brand.colorValue;
            }

            if (brand.bannerUrl) {
                banner.bgImg = brand.bannerUrl;
            }

            if (brand.logo) {
                _.set(banner, 'brandLogo.img', _getForceSourceUrl(brand.logo));
            }
        }
    }

    switch (_.toNumber(shop.type)) {
        case 1:
            // 多品店不显示
            banner = {};
            break;
        case 2:
            // 单品店显示新版的店铺banner
            _.forEach(shop.list, value => {
                if (value.resource_name === 'shopTopBanner') {
                    banner.bgImg = _.get(JSON.parse(value.resource_data), 'detailSrc', false);
                }
            });
            break;
        default:
            break;
    }

    if (!_.isEmpty(banner)) {
        resData.brandBanner = banner;
    }

    return resData;
};

/**
 * 设置商品基本信息
 * @function setProductData
 * @param { Object } base 接口返货商品数据
 * @return { Object } 商品基本信息
 */
const setProductData = base => {
    let resData = {
        id: base.id,
        name: base.productName,
        brandName: _.has(base, 'brand.brandName') ? base.brand.brandName : '',
        intro: base.salesPhrase,
        sellPrice: base.productPriceBo.salesPrice,
        marketPrice: base.productPriceBo.marketPrice,
        total: 0
    };

    let chooseSkuFlag;

    if (_.toNumber(resData.sellPrice) >= _.toNumber(resData.marketPrice)) {
        // 售价与吊牌价相同，只显示售价
        _.unset(resData, 'marketPrice');
    }

    // 遍历颜色尺寸
    if (base.goodsList) {
        let goods = [];

        // 处理商品数据
        _.forEach(base.goodsList, function(value) {
            let group = {},
                thumbs = [],
                sizes = [];

            // 如果status为0，即skc下架时就跳过该商品
            if (!value.status) {
                return;
            }

            if (value.goodsImagesList) {
                group = {
                    name: value.colorName,
                    title: `${resData.name} ${value.colorName}`,
                    color: value.colorName,
                    total: 0
                };

                // 有RGB值限时rgb值没有则显示背景图
                if (value.colorCode) {
                    group.rgb = `#${value.colorCode}`;
                } else {
                    group.rgb = `url('${helpers.image(value.colorImage, 30, 30)}')`;
                }

                // 商品颜色列表
                _.forEach(value.goodsImagesList, function(subValue) {
                    thumbs.push(subValue.imageUrl);
                });
                group.thumbs = thumbs;

                // 缩略图空，不显示
                if (!thumbs.length) {
                    return;
                }

                // 默认第一张图片
                if (!_.has(resData, 'img')) {
                    resData.img = value.colorImage;
                }

                // 商品尺码列表
                _.forEach(value.goodsSizeBoList, function(subValue) {
                    let size = {
                        name: subValue.sizeName,
                        title: subValue.sizeName,
                        sku: subValue.goodsSizeSkuId,
                        num: _.toInteger(subValue.goodsSizeStorageNum),
                        goodsId: subValue.goodsId
                    };

                    // 虚拟商品,增加为一件
                    if (subValue.attribute === 3) {
                        size.num = size.num > 1 ? 1 : 0;
                    }

                    // 如果status为0，即skc下架时,则库存设为0
                    if (subValue.status === 0) {
                        size.num = 0;
                    }

                    // 单个sku商品的总数累加
                    group.total += size.num;

                    // 默认选中该sku商品
                    if (group.total > 0 && !chooseSkuFlag) {
                        resData.colorName = group.name;
                        group.cur = true; // 选中sku商品
                        chooseSkuFlag = true;
                    }

                    // 商品的总数累加
                    resData.total += size.num;

                    sizes.push(size);
                });
                group.sizes = sizes;
            }

            goods.push(group);
        });

        // 默认设置第一个选中
        if (goods.length && !chooseSkuFlag) {
            goods[0].cur = true;
        }

        resData.colors = goods;
    }

    // 限购商品
    if (base.isLimitBuy === 'Y') {
        let isBeginSale = (base.saleStatus && +base.saleStatus) === 1; // 是否开售
        let showStatus = 1; // 限购商品有关的展示状态

        if (base.showStatus) {
            showStatus = _.toInteger(base.showStatus);
        }

        let fashTopGoods = _FashionTopGoodsStatus(base.uid, showStatus, isBeginSale);

        // 潮流尖货状态
        resData.fashionTopGoods = {
            getLimitedCode: fashTopGoods.getLimitedCode, // 限购码状态
            hasLimitedCode: fashTopGoods.hasLimitedCode, // 是否已经获取限购码
            limitedCodeSoldOut: fashTopGoods.limitedCodeSoldOut, // 限购码是否已经抢光
            getLimitedCodeDis: fashTopGoods.getLimitedCodeDis // 限购码是否失效
        };

        if (fashTopGoods.soldOut) {
            resData.soldOut = fashTopGoods.soldOut;

            // totalStorageNum = 0;//改总数为已售磬
        } else {
            resData.openSoon = fashTopGoods.openSoon;// 即将开售
            resData.dis = fashTopGoods.dis;// 是否失效
            resData.buyNow = fashTopGoods.buyNow;// 是否立即购买
        }
    }

    let soldOut = +base.status === 0 || resData.total === 0;

    if (+base.attribute === 2) { // 非卖品
        resData.notForSale = true;
    } else if (soldOut) { // 已售磬
        resData.soldOut = true;
        _.unset(resData, 'fashionTopGoods');
    } else if (+base.attribute === 3) { // 虚拟商品
        // 虚拟商品老代码功能有问题，暂不处理
    } else {
        // 立即购买及即将开售不存在显示加入购物袋
        if (!resData.buyNow && !resData.openSoon) {
            resData.addToBag = true;
        }
    }

    // 分享相关，产品的链接
    resData.share = {
        weixinUrl: helpers.urlFormat(base.mainPath),
        shareTitle: resData.name,
        shareImg: resData.img,
        shareDesc: base.phrase
    };

    return resData;
};

/**
 * 设置品牌介绍
 * @function setBrandIntro
 * @param { Object } brand 品牌相关数据
 * @return { Object } 品牌介绍
 */
const setBrandIntro = brand => {
    let barndIntro = {};

    if (brand) {
        let text = _.replace(brand.brandIntro, /<\/?[^>]*>|\s*|(\n)|(\t)|(\r)/g, ''),
            more = '... <a href="javascript:;" class="more-brand-intro blue">了解更多>></a>';

        barndIntro = {
            brand: {
                titleEn: 'BRAND',
                titleCn: '品牌介绍',
                logo: brand.brandIco,
                fullIntro: brand.brandIntro,
                intro: _.truncate(text, {
                    length: 300,
                    omission: more
                })
            }
        };
    }
    return barndIntro;
};

/**
 * 设置商品描述
 * @function setDescriptionData
 * @param { Object } sizeInfo 尺寸信息
 * @param { Object } comfortInfo 试穿信息
 * @return { Object } 商品描述
 */
const setDescriptionData = (sizeInfo, comfortInfo) => {
    let resData = {};

    if (_.has(sizeInfo, 'productDescBo.erpProductId')) {
        let description = {
            titleEn: 'DESCRIPTION',
            titleCn: '商品信息'
        };
        let sex;

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

        let basic = [
            { key: '编号', value: sizeInfo.productDescBo.erpProductId },
            { key: '颜色', value: sizeInfo.productDescBo.colorName },
            { key: '性别', value: sex }
        ];

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

        description.basic = basic;

        if (comfortInfo) {
            let comfort = [];

            _.forEach(comfortInfo, value => {
                let i = 1;
                let blocks = [];
                let flag = false;

                do {
                    if (i === +value.wearSense.value) {
                        flag = true;
                        blocks.push({
                            cur: true
                        });
                    } else {
                        blocks.push({});
                    }
                    i++;
                } while (i <= 5);

                if (flag) {
                    comfort.push({
                        name: value.caption.caption,
                        minDes: value.caption.low,
                        blocks: blocks,
                        maxDes: value.caption.high
                    });
                }
            });

            description.comfort = comfort;
        }

        resData = {
            description: description
        };
    }

    return resData;
};

/**
 * 设置洗涤材质信息
 * @function setMaterialData
 * @param { Object } sizeInfo 尺寸信息
 * @return { Object } 洗涤材质信息
 */
const setMaterialData = sizeInfo => {
    let resData = {};
    let material = {};

    // 洗涤提示
    if (sizeInfo.washTipsBoList) {
        let wash = [];

        _.forEach(sizeInfo.washTipsBoList, value => {
            wash.push({
                name: value.caption,
                img: value.img
            });
        });

        if (!_.isEmpty(wash)) {
            material.wash = wash;
        }
    }

    // 商品材质[洗涤说明]
    if (sizeInfo.productMaterialList) {
        let detail = [];

        _.forEach(sizeInfo.productMaterialList, value => {
            detail.push({
                img: value.imageUrl,
                name: value.caption,
                enName: value.encaption,
                text: value.remark
            });
        });

        if (!_.isEmpty(detail)) {
            material.detail = detail;
        }
    }

    if (!_.isEmpty(material)) {
        Object.assign(material, {
            titleEn: 'MATERIALS',
            titleCn: '材料洗涤'
        });

        resData.material = material;
    }
    return resData;
};

/**
 * 设置尺寸信息
 * @function setSizeData
 * @param { Object } sizeInfo 尺寸信息
 * @return { Object } 尺寸信息
 */
const setSizeData = (sizeInfo) => {
    let resData = {};

    if (sizeInfo.sizeInfoBo) {
        let referenceName,
            boyReference,
            girlReference,
            gender;
        let size = {
            titleEn: 'SIZEINFO',
            titleCn: '尺码信息',
            sizeImage: sizeInfo.sizeImage
        };

        sizeInfo.sizeInfoBo = _sizeInfoBoSort(sizeInfo.sizeInfoBo);

        // 参考尺码
        if (_.has(sizeInfo, 'productExtra')) {
            boyReference = sizeInfo.productExtra.boyReference;
            girlReference = sizeInfo.productExtra.girlReference;
        }

        gender = _.has(sizeInfo, 'productDescBo.gender') ? sizeInfo.productDescBo.gender : 3;
        if (gender === 3 && boyReference) {
            referenceName = '参考尺码(男)';
        } else if (gender === 3 && girlReference) {
            referenceName = '参考尺码(女)';
        } else {
            referenceName = '参考尺码';
        }

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

        if (sizeInfo.sizeInfoBo.sizeAttributeBos) {
            let sizeTable = {};

            // 尺码信息头部
            sizeTable.thead = [{name: '吊牌尺码', id: '', width: 126}];

            // 显示参考尺码
            if (showReference) {
                sizeTable.thead.push({name: referenceName, id: '', width: 126});
            }

            _.forEach(sizeInfo.sizeInfoBo.sizeAttributeBos, value => {
                let th = {
                    name: value.attributeName || ' ',
                    id: value.id,
                    width: 126
                };

                if (size.sizeImage) {
                    th.doubt = true;
                }
                sizeTable.thead.push(th);
            });

            sizeTable.tbody = [];
            _.forEach(sizeInfo.sizeInfoBo.sizeBoList, 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 (sizeTable.thead[1] && showReference) {
                        sizeTable.thead[1] = {};
                    }
                }

                // 其他尺码信息
                value.sortAttributes.forEach(attr => {
                    sizes.push((attr.sizeValue || ' '));
                });

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

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

            size.param = sizeTable;
        }

        if (_.isEmpty(_.get(size, 'param.tbody', ''))) {
            return {}; // 无尺码信息则不显示该块
        }

        if (!_.isEmpty(sizeInfo.modelBos)) {
            let tasteTable = {};

            tasteTable.thead = [
                {name: '模特', width: 170},
                {name: '身高', width: 126},
                {name: '体重', width: 126},
                {name: '三围', width: 126},
                {name: '吊牌尺码', width: 126},
                {name: '试穿描述', width: 126}
            ];

            tasteTable.tbody = [];
            _.forEach(sizeInfo.modelBos, value => {
                let modelInfo = [
                    {
                        img: value.avatar,
                        name: value.modelName
                    },
                    value.height, value.weight, value.vitalStatistics,
                    value.fitModelBo.fit_size, value.fitModelBo.feel
                ];

                // 是否有备注
                if (_.get(value, 'fitModelBo.fit_remark', false)) {
                    modelInfo.push(value.fitModelBo.fit_remark);
                    tasteTable.thead[7] = {name: '备注', width: 170};
                }
                tasteTable.tbody.push(modelInfo);
            });

            size.taste = tasteTable;
        }

        resData.sizeInfo = size;
    }
    return resData;
};

/**
 * 设置商品详情页介绍
 * @function setDetailData
 * @param { Object } sizeInfo 尺寸信息
 * @return { Object } 商品详情描述
 */
const setDetailData = sizeInfo => {
    let resData = {};

    // 详情配图
    if (_.has(sizeInfo, 'productIntroBo.productIntro')) {
        let details = {
            titleEn: 'DETAILS',
            titleCn: '商品详情'
        };

        if (sizeInfo.productDescBo && sizeInfo.productDescBo.phrase) {
            details.content = `${sizeInfo.productDescBo.phrase}<br/>`;
        }

        // 图片换规则
        const replacePairs = [
            {
                reg: /<img src=/g,
                str: '<img class="lazy" src="data:image/gif;base64,R0lGODlhAQABAJEAAAAAAP///93d3f' +
            '///yH5BAEAAAMALAAAAAABAAEAAAICVAEAOw==" data-original='
            },
            {
                reg: /<img border="0" src=/g,
                str: '<img border="0" class="lazy" src="data:image/gif;base64,R0lGODlhAQABAJEAAAAAAP' +
            '///93d3f///yH5BAEAAAMALAAAAAABAAEAAAICVAEAOw==" data-original='
            }
        ];
        let content = sizeInfo.productIntroBo.productIntro;

        // 图片换成懒加载方式
        _.forEach(replacePairs, value => {
            content = _.replace(content, value.reg, value.str);
        });
        details.content += content;

        resData.details = details;
    }
    return resData;
};

module.exports = {
    setSeoInfo,
    setBrandBanner,
    setPathNav,
    setProductData,
    setBrandIntro,
    setDescriptionData,
    setMaterialData,
    setSizeData,
    setDetailData
};