/**
 * 购物车处理类
 */

'use strict';

const helpers = global.yoho.helpers;
const _ = require('lodash');
const productProcess = require('./product-process');

// const regPromoTitle = /^【[^】]+】(.*)/;

const transPrice = (price, isSepcialZero) => {
    return (price > 0 || isSepcialZero) ? parseFloat(price).toFixed(2) : 0;
};

// const formatPromotionTitle = (promo) => {
//     let title;

//     if (promo.status === 0) {
//         if (promo.condition_unit === 1) {
//             title = `再购${Math.abs(promo.condition_value)}件`;
//         } else if (promo.condition_unit === 2) {
//             title = `再购¥${transPrice(Math.abs(promo.condition_value))}`;
//         }
//     } else {
//         title = '已满足';
//     }
//     let match = regPromoTitle.exec(promo.promotion_title);
//     let promotionTitle = match !== null && match.length > 1 ? match[1] : promo.promotion_title;

//     promotionTitle = promotionTitle.replace(/￥/g, '¥');
//     return `${title}【${promotionTitle}】`;
// };
const formatPromotionOpt = (promo) => {
    if (promo.status === 0) {
        return '去凑单';
    }
    if (promo.status === 10) {
        if (promo.promotion_type === 'Needpaygift') {
            return '去换购';
        }
        if (promo.promotion_type === 'Gift') {
            return '领赠品';
        }
        return '';
    }
    if (promo.status === 20) {
        return '已抢光';
    }
    if (promo.status === 30) {
        return '更换';
    }
};

/**
 * 格式化加价购和赠品商品
 *
 * @param array $advanceGoods 加价购商品列表
 * @param int $count 计商品件数
 * @return array $arr 处理之后的加价购商品数据
 */
const formatAdvanceGoods = (gifts, isGift) => {
    return _.map(gifts, gift => {
        return {
            promotionId: gift.promotion_id,
            promotionTitle: gift.promotion_title,
            isGift: isGift,
            goods: _.map(gift.goods_list, good => {
                return {
                    id: good.product_skn,
                    name: good.product_name,
                    thumb: good.goods_images ? helpers.image(good.goods_images, 120, 160) : '',
                    price: isGift ? '0.00' : transPrice(good.last_price),
                    salesPrice: good.last_price !== good.sales_price ? transPrice(good.sales_price) : false,
                    count: good.storage_number
                };
            })
        };
    });
};

/**
 * 格式化购物车商品
 *
 * @param array $cartGoods 购物车商品列表
 * @param bool $isAdvanceCart 是否是预售购物车（和上市期有关）
 * @param boolean $isValid 是否是可用商品（非失效商品），默认是
 * @param boolean $inValidLow 是否失效类型的库存不足，默认否
 * @return array 处理之后的购物车商品数据
 */
const formatCartGoods = (goodData, isAdvanceCart, isValid, inValidLow) => {
    if (typeof isValid === 'undefined') {
        isValid = true;
    }
    if (typeof inValidLow === 'undefined') {
        inValidLow = false;
    }

    let result = {
        id: goodData.product_sku,
        skn: goodData.product_skn,
        name: goodData.product_name,
        thumb: goodData.goods_images ? helpers.image(goodData.goods_images, 120, 160) : '',
        color: goodData.factory_goods_name || goodData.color_name,
        size: goodData.size_name,
        checked: goodData.selected === 'Y',
        price: transPrice(goodData.last_vip_price),
        salesPrice: goodData.sales_price !== goodData.last_vip_price ? transPrice(goodData.sales_price) : false,
        isVipPrice: goodData.sales_price !== goodData.last_vip_price && goodData.discount_tag === 'V',
        isStudents: goodData.sales_price !== goodData.last_vip_price && goodData.discount_tag === 'S',
        count: goodData.buy_number,
        promotion_id: _.toNumber(goodData.promotion_id) === 0 ? '' : goodData.promotion_id
    };

    goodData.storage_number = _.parseInt(goodData.storage_number);
    goodData.min_buy_number = _.parseInt(goodData.min_buy_number);
    goodData.buy_number = _.parseInt(goodData.buy_number);

    if (goodData.min_buy_number && goodData.min_buy_number > 0) {
        result.minNumber = goodData.min_buy_number;
    }
    result.maxNumber = goodData.storage_number;
    result.minSelectNum = goodData.buy_number <= goodData.min_buy_number || goodData.buy_number === 1;
    result.maxSelectNum = goodData.buy_number >= goodData.storage_number && goodData.goods_type === 'ordinary';

    if (isValid) {
        // 库存不足
        result.lowStocks = goodData.buy_number > goodData.storage_number;
    } else { // 失效商品
        result.inValid = true;
        result.inValidLow = inValidLow;
    }

    if (inValidLow && goodData.storage_number > 0) {
        result.reAddToCart = true;
    }

    // gift=>是否赠品,advanceBuy=>是否加价购,soldOut=>失效商品;
    if (!goodData.goods_type) {
        result.inValid = true;
    } else if (goodData.goods_type === 'gift' && !goodData.isAdvanceBuy) {
        result.isGift = true;
        result.salesPrice = transPrice(goodData.sales_price);
        result.price = transPrice(goodData.last_price);
        result.maxNumber = 1;
    } else if (goodData.goods_type === 'price_gift') {
        result.showCheckbox = true;
        result.isAdvanceBuy = true;
        result.salesPrice = transPrice(goodData.sales_price);
        result.price = transPrice(goodData.last_price);
        result.maxNumber = 1;
    } else {
        result.showCheckbox = true;
    }

    // 上市期
    if (isAdvanceCart && goodData.expect_arrival_time) {
        result.appearDate = goodData.expect_arrival_time;
    }

    // 商品链接
    result.link = helpers.urlFormat(`/product/${goodData.product_skn}.html`); // 商品url改版
    return result;
};

/**
 * 失效商品池数据处理
 * @param {*} pool
 */
const formatValidPool = (pool) => {
    let poolTemp = {
        poolBuyNumber: pool.pool_buy_number,
        poolId: pool.pool_id,
        poolBatchNo: pool.pool_batch_no, // 套餐批次
        poolStorageNumber: pool.pool_storage_number,
        poolTitle: pool.pool_title,
        selected: pool.selected,
        showCheckbox: false,
        isBundle: true
    };

    poolTemp.goods = _.get(pool, 'goods_list', []).map(good => {
        return formatCartGoods(good, false, false, true);
    });

    return poolTemp;
};

const procPriceGiftData = (data, promotionType) => {
    let result = {};
    let arrays = _.get(data, 'arrays', []);

    // 赠品和加价购
    result.gifts = formatAdvanceGoods(arrays, promotionType === 'Gift');
    if (result.gifts.length === 1) {
        result.promotionTitle = result.gifts[0].promotionTitle;
    }
    return result;
};

const getPromotionFlag = (promo) => {
    switch (promo.promotion_type) {
        case 'Cashreduce': // 满减
        case 'SpecifiedAmount': // X件X元
        case 'Cheapestfree':// 满X免1
            return '满减';
        case 'Degressdiscount':// 分件折扣
        case 'Discount':// 打折
            return '折扣';
        case 'Gift':// 赠品
            return '赠品';
        case 'Needpaygift':// 加价购
            return '加价购';
        default:
            return '';
    }
};
const formatPromotion = (promo) => {
    return {
        status: promo.status,
        conditionUnit: promo.condition_unit,
        conditionValue: promo.condition_value,
        giftPrice: promo.gift_price,
        promotionId: _.get(promo, 'ts_promotion_ids', 0),
        promotionOriginTitle: promo.promotion_title,
        promotionTitle: _.get(promo, 'promotion_desc', ''),
        promotionType: promo.promotion_type,
        alreadyMatch: promo.alreadyMatch,
        optTitle: formatPromotionOpt(promo),
        promotionFlag: getPromotionFlag(promo),
        noStorage: promo.status === 20
    };
};

/**
 * 处理购物车商品、加价购商品、赠品详情数据
 *
 * @param array $productData 要处理的商品数据
 * @param int $num 购买数目
 * @return array $data 处理之后的数据
 * @internal param null $mnum 量贩最小购买数量
 */
const procGoodsDetail = (productData, num) => {
    let data = {};
    let sizeInfo = productProcess.processSkusInfo(productData);

    Object.assign(data, sizeInfo);
    data.productSkn = productData.product_skn;
    if (_.has(productData, 'special_price')) { // 加价购或者赠品的销售价字段
        data.price = productData.format_market_price;
        data.salePrice = productData.format_sales_price;
    } else { // 购物车商品的销售价字段
        data.price = productData.market_price > productData.sales_price ? productData.format_market_price : false;
        data.salePrice = '¥' + transPrice(productData.sales_price);
    }


    if (_.has(productData, 'storage_sum')) {
        data.storage = productData.storage_sum;
    }
    data.num = 1;
    if (num) {
        data.num = _.parseInt(num);
    }
    data.colorName = '颜色';
    data.sizeName = '尺码';
    return data;
};

const procCartData = (data, isAdvanceCart) => {
    if (typeof isAdvanceCart === 'undefined') {
        isAdvanceCart = true;
    }
    let result = {};

    // 购买的可用商品列表
    result.goods = _.get(data, 'goods_list', []).map(good => {
        let gr = formatCartGoods(good, isAdvanceCart);

        if (gr.isGift) {
            gr.noEdit = true;
        }
        return gr;
    });
    result.goodPools = _.get(data, 'goods_pool_list', []).map(pool => {
        return {
            isBrand: pool.pool_type <= 1,
            isPromotion: pool.pool_type === 2,
            isBundle: pool.pool_type === 3,
            poolTitle: pool.pool_title,
            poolBuyNumber: pool.pool_buy_number,
            poolId: pool.pool_id, // 套餐 activity_id
            poolBatchNo: pool.pool_batch_no, // 套餐批次
            selected: pool.selected === 'Y', // 套餐是否选中
            poolStorageNumber: pool.pool_storage_number, // 库存数量
            goods: _.get(pool, 'goods_list', []).map(good => {
                return formatCartGoods(good, isAdvanceCart);
            }),
            promotions: _.get(pool, 'promotion_list', []).map(promo => {
                return formatPromotion(promo);
            }),
            promotionMore: _.get(pool, 'promotion_list', []).length > 1,
            sub_pool: _.get(pool, 'sub_pool', []).map(subPool => {
                return {
                    isBrand: subPool.pool_type <= 1,
                    isPromotion: subPool.pool_type === 2,
                    goods: _.get(subPool, 'goods_list', []).map(good => {
                        return formatCartGoods(good, isAdvanceCart);
                    }),
                    promotions: _.get(subPool, 'promotion_list', []).map(promo => {
                        return formatPromotion(promo);
                    }),
                    promotionMore: _.get(subPool, 'promotion_list', []).length > 1
                };
            })
        };
    });

    // 失效商品列表，库存为0
    result.notValidGoods = _.get(data, 'sold_out_goods_list', []).map(good => {
        return formatCartGoods(good, isAdvanceCart, false, true);
    });

    // 失效的商品池
    result.notValidPool = _.get(data, 'sold_out_goods_pool', []).map(pool => {
        return formatValidPool(pool);
    });

    // 下架的商品列表
    result.offShelveGoods = _.get(data, 'off_shelves_goods_list', []).map(good => {
        return formatCartGoods(good, isAdvanceCart, false);
    });

    // 赠品和加价购商品
    if (_.get(data, 'g_gift_list', []).length || _.get(data, 'g_price_gift_list', []).length) {
        result.freebieOrAdvanceBuy = true;

        // 赠品
        result.freebie = data.g_gift_list.filter(freebie => freebie.status !== 30 && freebie.status !== 0);
        result.selectFreebie = result.freebie.filter(freebie => freebie.status === 10);
        result.giftHasStorage = _.some(result.freebie, freebie => freebie.status === 10);

        // 加价购
        result.advanceBuy = data.g_price_gift_list.filter(advanceBuy => advanceBuy.status !== 30 && advanceBuy.status !== 0);// eslint-disable-line
        result.selectAdvanceBuy = result.advanceBuy.filter(advanceBuy => advanceBuy.status === 10);
        result.advanceHasStorage = _.some(result.advanceBuy, advanceBuy => advanceBuy.status === 10);
    }
    result.matchGifts = _.get(data, 'match_gift_ids', []);

    // 已参加的活动
    if (data.promotion_info && data.promotion_info.length > 0) {
        result.promotionInfo = data.promotion_info.map(promotion => {
            return {id: promotion.promotion_id, name: promotion.promotion_title};
        });
    }
    result.shipCost = {
        isFree: _.get(data, 'shipping_cost_prompt.is_shipping_cost_free', 'N'),
        shippingTip: _.get(data, 'shipping_cost_prompt.shipping_cost_tips', '').replace(/￥/g, '¥')
    };

    // 计算正常商品且有库存的总数
    let goodCount = _.sum(result.goods
        .filter(good => good.lowStocks === false)
        .map(good => {
            return _.parseInt(good.count, 10);
        })) + // 普通商品

        _.sum(result.goodPools
            .map(goodPool => {
                return _.sum(_.get(goodPool, 'sub_pool', [])
                    .map(subPool => {
                        return _.sum(_.get(subPool, 'goods', [])// 子促销池中的商品
                            .filter(good => good.lowStocks === false)
                            .map(good => {
                                return _.parseInt(good.count, 10);
                            }));
                    })) +
                        _.sum(_.get(goodPool, 'goods', []) // 大促销池中的商品
                            .filter(good => good.lowStocks === false)
                            .map(good => {
                                return _.parseInt(good.count, 10);
                            }));
            }));

    // 结算数据

    result.formulaPrice = data.shopping_cart_data.promotion_formula;
    result.count = data.shopping_cart_data.selected_goods_count;
    result.isAllSelected = (goodCount <= data.shopping_cart_data.selected_goods_count) && (data.shopping_cart_data.selected_goods_count > 0);// eslint-disable-line
    result.sumPrice = transPrice(data.shopping_cart_data.last_order_amount);
    result.hasNoSaleGoods = result.notValidGoods.length ||
        result.offShelveGoods.length ||
        result.notValidPool.length;

    return result;
};
const processData = (data, cartType) => {
    if (typeof cartType === 'undefined') {
        cartType = 'all';
    }
    let cart = data.data;
    let result = {};
    let ordinaryCount = _.get(cart, 'ordinary_cart_data.shopping_cart_data.goods_count', 0);
    let advanceCount = _.get(cart, 'advance_cart_data.shopping_cart_data.goods_count', 0);
    let ordinarySoldOut = _.get(cart, 'ordinary_cart_data.sold_out_goods_list', []);
    let advanceSoldOut = _.get(cart, 'advance_cart_data.sold_out_goods_list', []);

    // 普通购物车和预售购物车都为空
    if (ordinaryCount === 0 && advanceCount === 0 && !ordinarySoldOut.length && !advanceSoldOut.length) {
        result.isEmptyCart = true;
        return result;
    }

    /* 普通购物车 */
    result.commonGoodsCount = ordinaryCount;
    result.ordinarySoldOut = ordinarySoldOut.length;
    result.commonCart = procCartData(cart.ordinary_cart_data, false);

    /* 预售购物车 */
    result.presellGoodsCount = advanceCount;
    result.advanceSoldOut = advanceSoldOut.length;
    result.preSellCart = procCartData(cart.advance_cart_data);
    return result;
};


/**
 * 获取处理量贩数据
 * @param $productSkn
 * @return array
 */
const handleBundleInfo = (apiResult) => {
    let result = {};

    if (apiResult && apiResult.code === 200 && apiResult.data) {
        let discountBuy = _.find(apiResult.data, bund => _.get(bund, 'bundleInfo.discountType') === 2);

        if (discountBuy) {
            result.num = discountBuy.bundleInfo.bundleCount;
            result.discount = _.has(discountBuy.bundleInfo, 'discount') ? discountBuy.bundleInfo.discount : false;
            result.promotionPhrase = discountBuy.bundleInfo.promotionPhrase;
        }
    }

    return result;
};

module.exports = {
    processData,
    procGoodsDetail,
    handleBundleInfo,
    procPriceGiftData
};