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

'use strict';

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

const SINGLE_TICKETS_SKN = 51257524;// 展览票

/**
 * 获取用户数据信息
 * @param  {[string]} uid
 * @return {[array]}
 */
const _getUserProfile = (uid) => {
    if (!uid) {
        return Promise.resolve({
            code: 200,
            data: {}
        });
    }
    return api.get('', {
        method: 'app.passport.profile',
        uid: uid
    }, {
        cache: true
    });
};

/**
 * 处理品牌关联店铺信息
 * @param  {array}
 * @return {array}
 */
const _processShopsInfo = (data) => {
    let enterStore = [];

    _.forEach(data, function(value) {
        let shopInfo = {
            img: value.brand_ico,
            storeName: value.brand_name
        };

        if (value.shop_id) {
            shopInfo.url = helpers.urlFormat('/product/index/brand', {
                shop_id: value.shop_id
            });
        } else {
            shopInfo.url = helpers.urlFormat('', null, value.brand_domain);
        }

        enterStore.push(shopInfo);
    });
    return enterStore;
};

/**
 * 处理限购商品的有关按钮状态（或取现购买以及底部商品购买按钮）
 * @param  {array} 需要处理的数据
 * @param  {int} 限购商品的关联状态
 * @param  {Boolean} 限购商品是否已开售
 * @return {array}
 */
const _procShowStatus = (data, showStatus, isBeginSale) => {
    switch (showStatus) {
        case 1: // 开售前/后，立即分享获得限购码（用户未领取限购码）
            // 显示获取限购码按钮
            data.canGetLimitCode = true;

            if (isBeginSale) { // 开售后
                data.cartInfo.noLimitCode = true;
            } else {
                data.cartInfo.limitNotForSale = true;
            }
            break;
        case 2: // 开售后，限购码已抢光（用户未领取限购码）
            data.codeEmpty = true;
            data.cartInfo.noLimitCode = true;
            break;
        case 3: // 开售后，商品已经售罄
            data.noLimitGoodsBtn = true;
            data.cartInfo.soldOut = true;
            break;
        case 4: // 开售后，立即购买（用户已领取限购码）
            data.gotCode = true;
            data.cartInfo.canBuyLimit = true;
            break;
        case 5: // 开售前，限购码已被抢光（用户未领取限购码）
            data.codeEmpty = true;
            data.cartInfo.limitNotForSale = true;
            break;
        case 6: // 开售前，即将开售（用户已领取限购码）
            data.gotCode = true;
            data.cartInfo.limitNotForSale = true;
            break;
        case 7: // 开售后，用户已经用获得的限购码购买过商品
            data.gotCode = true;
            data.cartInfo.noLimitCode = true;
            break;
        default:
            break;
    }

    return data;
};

/**
 * 根据设备类型获得限购商品跳转app的url
 * @param  {string} productCode 限购商品码
 * @param  {string} skn 限购商品skn
 * @return {string} 限购商品跳转url
 */
const _getLimitCodeUrl = (productCode, skn, ua) => {
    let url = 'yohoapp://yoho.app/openwith?limit_product_code=' + productCode +
        '&product_skn=' + skn;

    let isIphone = String(ua).indexOf('iPhone') >= 0;
    let isIpad = ua.indexOf('iPad') >= 0;

    if (isIphone || isIpad) {
        let params = {};

        params.lp = productCode;
        url = 'yohobuy://' + helpers.urlFormat('/limitpurchase', params);
    }
    return url;
};

/**
 * 详情页数据格式化
 * @param origin Object 原始数据
 * @return dest Object 格式化数据
 */
const _detailDataPkg = (origin, uid, vipLevel, ua) => {
    let dest = {}, // 结果输出
        thumbImageList = [],
        colorGroup = {},
        sizeGroup = [],
        totalStorageNum = 0;

    // 商品名称
    if (origin.productName === null || typeof origin.productName === 'undefined') {
        return dest;
    }

    dest.goodsName = origin.productName;

    // 是否是虚拟商品
    dest.virtualGoods = origin.attribute * 1 === 3 ? true : false;

    // 用户未登录时
    if (!uid) {
        let params = {};

        params.refer = helpers.urlFormat('/product/show_' + origin.erpProductId + '.html');
        dest.loginUrl = helpers.urlFormat('/signin.html', params);
    }

    // 商品促销短语
    if (origin.salesPhrase) {
        dest.goodsSubtitle = origin.salesPhrase;
    }

    // 商品标签
    if (origin.productTagBoList) {
        let productTags = {};

        _.forEach(origin.productTagBoList, function(value) {
            switch (value.tagLabel) {
                case 'is_soon_sold_out':
                    productTags.is_soon_sold_out = true;
                    break;
                case 'is_new':
                    productTags.is_new = true;
                    break;
                case 'is_discount':
                    productTags.is_discount = true;
                    break;
                case 'is_limited':
                    productTags.is_limited = true;
                    break;
                case 'is_yohood':
                    productTags.is_yohood = true;
                    break;
                case 'is_advance':
                    productTags.is_advance = true;
                    break;
                default:
                    break;
            }
        });

        dest.tags = productTags;
    }

    // 商品价格
    if (origin.productPriceBo) {
        let originPrice = origin.productPriceBo;
        let goodsPrice = {
            currentPrice: originPrice.formatSalesPrice
        };

        if (originPrice.formatMarketPrice !== originPrice.formatSalesPrice) {
            goodsPrice.previousPrice = originPrice.formatMarketPrice;
        }

        dest.goodsPrice = goodsPrice;

        // 商品返回 YOHO 币
        if (originPrice.yohoCoinNum) {
            dest.commodityReturn = originPrice.yohoCoinNum;
        }
    }

    // VIP 商品价格
    if (origin.productPriceBo.vipPrices) {
        let vipList = [];

        _.forEach(origin.productPriceBo.vipPrices, function(value) {
            vipList.push({
                level: value.vipLevel,
                text: value.vipPrice,
                currentLevel: (value.vipLevel === vipLevel)
            });
        });

        if (vipList.length) {
            dest.vipLevel = {
                list: vipList
            };
        }

    }

    // 上市期
    if (origin.expectArrivalTime) {
        dest.periodOfMarket = `${origin.expectArrivalTime}月`;
    }

    // 促销信息 TODO: 换新接口
    if (origin.promotionBoList) {
        let discountList = [];

        _.forEach(origin.promotionBoList, function(value) {
            discountList.push({
                text: `【${value.promotionType}】${value.promotionTitle}`
            });
        });

        if (discountList.length) {
            dest.goodsDiscount = {
                list: discountList
            };
        }
    }

    // 商品咨询
    dest.feedbacks = {
        consults: [],
        consultsNum: 0
    };

    if (origin.consultBoWrapper) {
        dest.feedbacks.consultsNum = origin.consultBoWrapper.consultTotal;
        _.forEach(origin.consultBoWrapper.consultBoList, function(value) {
            dest.feedbacks.consults.push({
                question: value.ask,
                time: value.askTime,
                answer: value.answer
            });
        });
    }

    let consultParams = {
        product_id: origin.id
    };

    if (_.has(dest, 'feedbacks.consultsNum')) {
        consultParams.total = dest.feedbacks.consultsNum;
        dest.feedbacks.consultsUrl = helpers.urlFormat('/product/detail/consult', consultParams);
    } else {
        dest.feedbacks.consultsUrl = helpers.urlFormat('/product/detail/consultform', consultParams);
    }


    // 商品评价
    dest.feedbacks.commentsNum = 0;
    if (origin.commentBoWrapper) {
        dest.feedbacks.commentsNum = origin.commentBoWrapper.commentTotal;

        let commentList = [];

        _.forEach(origin.commentBoWrapper.commentBoList, function(value) {
            commentList.push({
                userName: value.nickName,
                desc: `${value.colorName}/${value.sizeName}`,
                content: value.content ? value.content : '',
                time: value.createTime
            });
        });

        dest.feedbacks.comments = commentList;

        dest.feedbacks.commentsUrl = helpers.urlFormat('/product/detail/comments', {
            product_id: origin.id,
            total: dest.feedbacks.commentsNum
        });
    }

    // 品牌信息
    if (origin.brand) {
        let extra = `?productSkn=${origin.erpProductId}&brandId=${origin.brand.id}`;

        dest.preferenceUrl = `/product/detail/preference${extra}`;
    }

    dest.productSkn = origin.erpProductId;

    // 商品信息
    if (origin.goodsList) {
        let goodsGroup = [],
            sizeName = '',
            colorList = {},
            sizeList = {},
            allSizeList = {},
            colorStorageGroup = {},
            colorStorageNum = 0;

        _.forEach(origin.goodsList, function(value, key) {
            if (value.status === 0) {
                return;
            }

            colorStorageNum = 0;

            // 商品分组
            if (value.goodsImagesList) {
                _.forEach(value.goodsImagesList, function(good) {
                    goodsGroup.push({
                        goodsId: good.goodsId,
                        img: good.imageUrl
                    });
                });
            }

            // 商品的尺码列表
            colorStorageGroup[value.productSkc] = {};
            if (value.goodsSizeBoList) {
                sizeList[value.productSkc] = [];
                _.forEach(value.goodsSizeBoList, function(size) {
                    sizeList[value.productSkc].push({
                        id: size.id,
                        skuId: size.goodsSizeSkuId,
                        goodsId: size.goodsId,
                        colorId: size.colorId,
                        name: size.sizeName,
                        sizeNum: size.goodsSizeStorageNum
                    });

                    sizeName = size.sizeName;

                    // 所有尺码列表，赋值用于前端展示默认尺码的时候
                    // 判断出没有库存则显示灰色
                    let build = {
                        id: size.id,
                        storage: size.goodsSizeStorageNum
                    };

                    allSizeList[sizeName] = (allSizeList[sizeName] === null ||
                            typeof allSizeList[sizeName] === 'undefined') ? build :
                        allSizeList[sizeName];

                    colorStorageNum += parseInt(size.goodsSizeStorageNum, 10);
                    colorStorageGroup[value.productSkc][sizeName] = parseInt(size.goodsSizeStorageNum, 10);
                });

                // 颜色分组
                colorList[key] = {
                    id: value.colorId,
                    skcId: value.productSkc,
                    name: value.colorName,
                    goodsName: value.goodsName,
                    colorNum: colorStorageNum
                };
            }

            // 缩略图
            thumbImageList.push({
                img: value.colorImage
            });

            // 商品库存总数
            totalStorageNum += _.toNumber(colorStorageNum);
        });

        // 遍历所有尺码，构建颜色显示数据
        let i = 1;

        sizeGroup[0] = {
            size: []
        };
        _.forEach(allSizeList, function(value) {
            // 默认尺码
            sizeGroup[0].size.push({
                name: sizeName,
                sizeNum: _.toNumber(value.storage) > 0 ? true : false,
                id: value.id
            });

            colorGroup[i] = {
                color: []
            };

            // 各个颜色的尺码, 每行显示一个尺码对应的颜色
            _.forEach(colorList, function(colorArr) {
                colorArr.colorNum = 0;
                if (colorStorageGroup[colorArr.skcId] &&
                    colorStorageGroup[colorArr.skcId][sizeName]) {
                    colorArr.colorNum = colorStorageGroup[colorArr.skcId][sizeName];
                }
                colorGroup[i].color.push(colorArr);
            });
            colorGroup[i].id = value.id;

            ++i;
        });

        colorGroup[0] = {
            color: []
        };

        // 遍历所有颜色, 构建尺码显示数据
        i = 1;
        _.forEach(colorList, function(value) {
            // 各个尺码的颜色， 每行显示一个颜色的对应尺码
            sizeGroup[i] = {
                size: sizeList[value.skcId],
                colorId: value.skcId
            };

            // 默认颜色
            colorGroup[0].color.push(value);
            ++i;
        });

        // 商品图：多个
        if (goodsGroup.length > 1) {
            let bannerList = [];

            _.forEach(goodsGroup, function(value) {
                bannerList.push({
                    img: value.img
                });
            });

            dest.bannerTop = {
                list: bannerList
            };
        } else if (goodsGroup[0] !== null && typeof goodsGroup[0] !== 'undefined') {
            dest.bannerTop = {
                img: goodsGroup[0].img
            };
        }
    }

    // 悬浮的购物车信息
    dest.cartInfo = {
        cartUrl: helpers.urlFormat('/cart/index/index'),
        numInCart: 0,
        goodsInstore: origin.storage
    };

    let soldOut = (origin.storage === 0) || (origin.status === 0 || totalStorageNum === 0);
    let notForSale = origin.attribute === 2;

    // 显示加入购物车链接
    if (!soldOut && !notForSale) {
        _.orderBy(colorGroup);

        Object.assign(dest.cartInfo, {
            productId: origin.id,
            thumbs: thumbImageList,
            name: dest.goodsName ? dest.goodsName : '',
            price: dest.goodsPrice.previousPrice ? dest.goodsPrice.previousPrice : '',
            salePrice: dest.goodsPrice.currentPrice ? dest.goodsPrice.currentPrice : '',
            totalNum: totalStorageNum,
            colors: _.toArray(colorGroup),
            sizes: sizeGroup
        });

        // 限购商品
        if (origin.isLimitBuy === 'Y') {
            // 是否开售
            let isBeginSale = (origin.saleStatus !== null && typeof origin.saleStatus !== 'undefined' &&
                origin.saleStatus === 1);

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

            if (origin.showStatus !== null && typeof origin.showStatus !== 'undefined') {
                showStatus = parseInt(origin.showStatus, 10);
            }

            // 处理限购商品有关的按钮状态
            dest = _procShowStatus(dest, showStatus, isBeginSale);

            dest.cartInfo.limitProductCode = origin.limitProductCode;
            dest.cartInfo.limitCodeUrl = _getLimitCodeUrl(origin.limitProductCode, origin.erpProductId, ua);
            dest.cartInfo.limitProductPay = helpers.urlFormat('/cart/index/orderEnsure');
        } else {
            dest.cartInfo.addToCartUrl = helpers.urlFormat('/product/buy_' + origin.id + '_' +
                origin.goodsList.id + '.html');
        }
    } else if (notForSale) {
        dest.cartInfo.notForSale = true;
    } else if (soldOut) {
        dest.cartInfo.soldOut = true;
    }

    // 是否收藏
    dest.isCollect = false;
    if (origin.isCollect !== null && typeof origin.isCollect !== 'undefined' && origin.isCollect === 'Y') {
        dest.isCollect = true;
    }

    // 底部简介URL链接
    dest.introUrl = '/product/detail/intro/' + origin.erpProductId;
    dest.id = origin.id;

    // 虚拟商品（门票）
    if (origin.attribute * 1 === 3) {
        dest.tickets = true;
        dest.ticketsConfirm = helpers.urlFormat('/cart/index/ticketsConfirm');

        // 展览票
        if (origin.erpProductId * 1 === SINGLE_TICKETS_SKN) {
            dest.single = true;
        } else {
            // 套票
            dest.package = true;
        }

        // 购票限制
        dest.cartInfo.limit = 4;

        // 清空活动
        dest.goodsDiscount = [];

        // 来自登录页，自动弹出选择框
        // if (isset($_GET['product_type']) && $_GET['product_type'] == 'ticket') {
        //     $result['showPannel'] = true;
        // }
    }

    return dest;
};

let _getShopsInfo = (brandId) => {
    return api.get('', {
        method: 'app.shop.queryShopsByBrandId',
        brand_id: _.toString(brandId)
    }, {
        cache: true
    }).then(shops => {
        if (shops.code === 200) {
            return _processShopsInfo(shops.data);
        }

        return [];
    });
};

let _getPromotionInfo = (skn) => {
    return api.get('', {
        method: 'app.product.promotion',
        product_skn: _.toString(skn)
    }, {
        cache: true
    }).then((result) => {
        if (result.code === 200) {
            return result.data;
        }

        return {};
    });
};

let getProductData = (data) => {
    let finalResult;
    let params = {
        productId: _.toString(data.id),
        method: 'h5.product.data'
    };

    if (!_.isEmpty(data.uid)) {
        params.uid = data.uid;
    }

    return _getUserProfile(params.uid).then((user) => {
        data.vipLevel = (user.data && user.data.vip_info && user.data.vip_info.cur_level) || '0';

        return api.get('', params, {
            cache: true
        }).then(result => {
            return Promise.all([_getShopsInfo(result.brandId), _getPromotionInfo(result.erpProductId)]).then((info) => {
                result.promotionBoList = info[1];

                finalResult = _detailDataPkg(result, data.uid, data.vipLevel, data.ua);
                finalResult.enterStore = info[0];

                return finalResult;
            });

        });
    });
};

module.exports = {
    getProductData
};