/*
 * @Author: sefon
 * @Date: 2016-07-24 11:48:22
 */

'use strict';
const utils = '../../../utils';
const searchApi = require('./search-api');
const shopApi = require('./shop-api');
const headerModel = require('../../../doraemon/models/header');
const productProcess = require(`${utils}/product-process`);
const searchHandler = require('./search-handler');
const shopHandler = require('./shop-handler');
const helpers = global.yoho.helpers;
const crypto = global.yoho.crypto;
const _ = require('lodash');

const limitNum = 60; // 商品每页显示数目
const needParams = ['query', 'msort', 'misort', 'gender', 'shelveTime'];

// 品牌页folder名称
const brandFolderSeries = '经典系列';

// 搜索分类信息需要的参数
const positionId = 10;

// 获取分类左侧广告id
const sortAdsId = 79;


const _getGender = (channel) => {
    let gender;

    switch (channel) {
        case 'boys':
            gender = '1,3';
            break;
        case 'girls':
            gender = '2,3';
            break;
        default:
            gender = '1,2,3';
            break;
    }

    return gender;
};

/**
 * 获取商品分类列表数据
 */
const getListData = (params, channel) => {
    let standard = [];

    _.forEach(params, (value, key) => {
        let s = _.split(key, 'parameter_', 2);

        if (s.length > 1) {
            standard.push(`${s[1]}_${value}`);
            _.unset(params, `${key}`);
        }
    });

    if (standard.length) {
        params.standard = standard.join(',');
    }

    let searchParams = searchHandler.getSearchParams(params);

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(channel),
        searchApi.getSortList(Object.assign({}, {msort: '', misort: ''})),
        searchApi.getProductList(searchParams)
    ];

    // 搜索分类介绍和广告
    if (params.msort && params.misort && !isNaN(params.misort)) {
        let IntroParams = {
            max_sort_id: params.msort,
            middle_sort_id: params.misort,
            gender: params.gender || '1,3'
        };

        apiMethod.push(searchApi.getSortIntro(Object.assign(IntroParams, {position_id: positionId})));
        apiMethod.push(searchApi.getSortAds(Object.assign(IntroParams, {position_id: sortAdsId})));
    }

    return Promise.all(apiMethod).then(result => {
        let finalResult = {
            headerData: Object.assign(result[0].headerData, {
                header: true
            }),
            list: {
                leftContent: {}
            }
        };

        // 获取左侧类目数据
        if (result[1].code === 200) {
            let dps = {};

            _.forEach(needParams, (value) => {
                if (params[value]) {
                    dps[value] = params[value];
                }
            });

            finalResult.list = Object.assign(
                searchHandler.handlePathNavData(result[1].data.sort, params, 'sort', channel), {
                    leftContent: searchHandler.handleSortData(result[1].data.sort, dps, params)
                });
        }

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            let filters = Object.assign(searchHandler.handleFilterDataAll(result[2].data, params),
                finalResult.list.leftContent.sort);

            filters.checkedConditions.conditions = _.concat(filters.checkedConditions.conditions,
                finalResult.list.leftContent.checked);

            Object.assign(finalResult.list, {
                filters: filters,
                opts: searchHandler.handleOptsData(params, result[2].data.total, result[2].data.filter),
                totalCount: result[2].data.total,
                footPager: searchHandler.handlePagerData(result[2].data.total, params),
                goods: productProcess.processProductList(result[2].data.product_list,
                    Object.assign({showDiscount: false}, params, {
                        from: {type: 'list', params: params}
                    })),
                hasNextPage: searchHandler.handleNextPage(params, result[2].data.total),

                // 最近浏览记录
                latestWalk: 6
            });
        }

        // 分类介绍
        if (result[3] && result[3].code === 200) {
            finalResult.list.sortIntro = searchHandler.handleSortIntro(result[3].data);
        }

        // 分类广告
        if (result[4] && result[4].code === 200) {
            Object.assign(finalResult.list.leftContent, searchHandler.handleSortAds(result[4].data));
        }

        finalResult.criteo = {skn: searchHandler.getCriteo(_.get(finalResult.list, 'goods'))};

        let seo = searchHandler.getListSeo(channel,
            _.get(finalResult, 'list.leftContent.allSort.list'),
            _.get(finalResult, 'list.filters.checkedConditions.conditions'));

        return Object.assign({}, seo, finalResult);
    });
};

/**
 * 获取新品到着数据
 */
const getListNewData = (params, channel) => {

    let searchParams = searchHandler.getSearchParams(params);

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(channel),
        searchApi.getSortList(Object.assign({}, {msort: '', misort: ''})),
        searchApi.getProductList(Object.assign(searchParams), 'newProduct'),
        searchApi.getWeekNew(params)
    ];

    return Promise.all(apiMethod).then(result => {
        let finalResult = {
            headerData: Object.assign(result[0].headerData, {
                header: true
            }),
            list: {
                leftContent: {}
            }
        };
        let dps = {};

        _.forEach(needParams, (value) => {
            if (params[value]) {
                dps[value] = params[value];
            }
        });

        // 获取左侧类目数据
        if (result[1].code === 200) {
            finalResult.list = Object.assign(
                searchHandler.handlePathNavData(result[1].data.sort, params, 'new', channel), {
                    leftContent: searchHandler.handleSortData(result[1].data.sort, dps, params)
                });
        }

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            let filters = Object.assign(searchHandler.handleFilterDataAll(result[2].data, params),
                finalResult.list.leftContent.sort);

            filters.checkedConditions.conditions = _.concat(filters.checkedConditions.conditions,
                finalResult.list.leftContent.checked);

            Object.assign(finalResult.list, {
                filters: filters,
                opts: searchHandler.handleOptsData(params, result[2].data.total, result[2].data.filter),
                totalCount: result[2].data.total,
                footPager: searchHandler.handlePagerData(result[2].data.total, params),
                goods: productProcess.processProductList(result[2].data.product_list,
                    Object.assign({showDiscount: false, showNew: false,
                        from: {type: 'listNew', params: params}}, params)),
                hasNextPage: searchHandler.handleNextPage(params, result[2].data.total),

                // 最近浏览记录
                latestWalk: 7
            });
        }

        // 新品上架
        if (result[3] && result[3].code === 200) {
            Object.assign(finalResult.list.leftContent, searchHandler.handleWeekNew(result[3].data, dps));
        }

        finalResult.criteo = {skn: searchHandler.getCriteo(_.get(finalResult.list, 'goods'))};

        let seo = searchHandler.getNewSeo(channel, _.get(finalResult, 'list.leftContent.newSales.list'));

        return Object.assign({}, seo, finalResult);
    });
};

/**
 * 根据品牌域名查询品牌信息
 */
const getBrandInfo = (params) => {
    return searchApi.getBrandData(params).then(result => {

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

        return {
            brandId: result.data.id,
            brandNameEn: result.data.brand_name_en || '',
            brandNameCn: result.data.brand_name_cn || '',
            brandBanner: result.data.brand_banner || '',
            node: result.data.static_content_code || '',
            brandAbout: result.data.brand_intro || '',
            shopTemplateType: result.data.shop_template_type || 0,
            url: helpers.urlFormat('', '', result.data.brand_domain),
            name: result.data.brand_name,
            shopId: result.data.shop_id || 0,
            type: result.data.type || 0,
            brandDomain: result.data.brand_domain
        };

    });
};

/**
 * 获取品牌页面数据
 */
const getBrandData = (params, extra, channel) => {
    let queryBase = {};
    let searchParams = searchHandler.getSearchParams(params);

    if (params.shopId) {
        // 店铺以店铺ID查询商品
        Object.assign(queryBase, {
            shop_id: params.shopId,
            shop: params.shopId
        });
    } else {
        // 品牌以品牌ID查询商品
        queryBase.brand = extra.brandId;
    }

    // 设置品牌默认排序方式
    let order = params.order || 'b_w_desc';

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(channel),
        searchApi.getSortList(queryBase),
        searchApi.getProductList(Object.assign(searchParams, {order: order}, queryBase))
    ];

    if (queryBase.brand) {
        apiMethod.push(searchApi.getBrandCouponAsync(queryBase.brand));
    }

    return Promise.all(apiMethod).then(result => {
        let finalResult = {
            headerData: Object.assign(result[0].headerData, {
                header: true
            }),
            brand: {
                brandBanner: searchHandler.handleBrandBanner(extra),
                leftContent: {},
                node: extra.node || '',
                brandId: extra.brandId
            }
        };

        // 获取左侧类目数据
        if (result[1].code === 200) {
            let dps = {};

            _.forEach(needParams, (value) => {
                if (params[value]) {
                    dps[value] = params[value];
                }
            });

            if (queryBase.shop_id) {
                dps.shopId = queryBase.shop_id;
            }

            Object.assign(finalResult.brand, {
                leftContent: searchHandler.handleSortData(result[1].data.sort, dps, params)
            }, searchHandler.handlePathNavData(extra, params, 'brand', channel));
        }

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            let filters = Object.assign(searchHandler.handleFilterDataAll(result[2].data, params),
                finalResult.brand.leftContent.sort);

            filters.checkedConditions.conditions = _.concat(filters.checkedConditions.conditions,
                finalResult.brand.leftContent.checked);

            Object.assign(finalResult.brand, {
                filters: filters,
                opts: searchHandler.handleOptsData(params, result[2].data.total, result[2].data.filter),
                totalCount: result[2].data.total,
                footPager: searchHandler.handlePagerData(result[2].data.total, params),
                goods: productProcess.processProductList(result[2].data.product_list,
                    Object.assign({showDiscount: false, from: {type: 'brand', params: params}}, params)),
                hasNextPage: searchHandler.handleNextPage(params, result[2].data.total),

                // 最近浏览记录
                latestWalk: 7
            });

            // 品牌页不显示品牌筛选项
            _.unset(finalResult, 'brand.filters.brand');
        }

        if (result[3] && result[3].data) {
            finalResult.brand.coupon = searchHandler.handleBrandShopCoupons(
                _.get(result[3], 'data.coupons', []), {brandId: extra.brandId});
        }

        finalResult.criteo = {skn: searchHandler.getCriteo(_.get(finalResult.brand, 'goods'))};

        let seo = searchHandler.getBrandShopSeo(channel, extra, params);

        return Object.assign({}, seo, finalResult);
    });
};

/**
 * 获取品牌介绍页面数据
 */
const getBrandAbout = (domain, uid, channel) => {
    channel = channel || 'boys';

    return Promise.all([
        headerModel.requestHeaderData(channel),
        searchApi.getBrandData({domain: domain})
    ]).then(result => {
        let home;
        let finalResult = {
            headerData: Object.assign(result[0].headerData, {
                header: true
            })
        };

        switch (channel) {
            case 'girls':
                home = helpers.urlFormat('/woman', {}, 'new');
                break;
            case 'lifestyle':
                home = helpers.urlFormat('/lifestyle', {}, 'new');
                break;
            case 'kids':
                home = helpers.urlFormat('/kids', {}, 'new');
                break;
            default:
                home = helpers.urlFormat('');
                break;
        }

        if (result[1].code === 200) {
            let data = result[1].data || {};
            let extra = {
                brandId: data.id,
                brandNameEn: data.brand_name_en || '',
                brandNameCn: data.brand_name_cn || '',
                brandBanner: data.brand_banner || '',
                node: data.static_content_code || '',
                brandAbout: data.brand_intro || '',
                shopTemplateType: data.shop_template_type || 0,
                url: helpers.urlFormat('', '', data.brand_domain),
                name: data.brand_name,
                shopId: data.shop_id || 0,
                type: data.type || 0,
                brandDomain: data.brand_domain
            };

            finalResult.brand = {
                brandBanner: searchHandler.handleBrandBanner(extra),
                pathNav: [
                    {
                        href: home,
                        name: `${_.toUpper(channel)}首页`,
                        pathTitle: 'YOHO!BUY 有货'
                    },
                    {
                        href: helpers.urlFormat('/brands'),
                        name: '品牌一览',
                        pathTitle: '品牌一览'
                    },
                    {
                        name: `${extra.brandNameEn} ${extra.brandNameCn}`
                    }
                ],
                brandAbout: {
                    brandIntro: extra.brandAbout
                }
            };
        }

        return finalResult;
    });
};


/**
 * 获取店铺介绍页面数据
 */
const getShopAbout = (shopId, uid, channel) => {
    let resData = {};

    return Promise.all([
        headerModel.requestHeaderData(channel),
        searchApi.getShopDecorator(shopId), // 店铺装修数据
        searchApi.getShopInfo(shopId, uid)
    ]).then(result => {
        resData.headerData = Object.assign(result[0].headerData, {
            header: true
        });

        if (result[1].code === 200) {
            let data = result[1].data || {},
                decorator = shopHandler.getShopDecorator(data, {}, shopId, true);

            Object.assign(decorator.shopTopBannerBase, {
                shopId: shopId,
                bannerHeight: 150,
                shopHome: `/?shopId=${shopId}`,
                shopIntro: `/about?shopId=${shopId}`,
                coled: _.get(result, '[2].data.is_favorite', 'N') === 'Y'
            });
            _.set(resData, 'brand.shopBanner', decorator.shopTopBannerBase);
            _.unset(resData, 'brand.brandBanner');
        }

        if (result[2].code === 200) {
            let data = result[2].data || {};

            _.set(resData, 'brand.brandAbout.brandIntro', data.shop_intro);
        }

        return resData;
    });
};

/**
 * 获取品牌页面水牌
 */
const getNodeContentData = (params) => {
    return searchApi.getNodeContent(params).then(result => {

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

/**
 * 获取品牌页面系列
 */
const getAdnav = (params) => {

    return Promise.all([searchApi.getBrandFolder(params), searchApi.getBrandSeries(params)]).then(result => {

        let dest = {
            picTitle: '',
            list: []
        };

        if (result[0].code === 200 && result[0].data) {
            dest.picTitle = brandFolderSeries;
            Object.assign(dest.list, searchHandler.handleFolderData(result[0].data));
        }

        if (result[1].code === 200 && result[1].data) {
            dest.picTitle = brandFolderSeries;
            Object.assign(dest.list, searchHandler.handleSeriesData(result[1].data));
        }


        return dest;
    });
};

/**
 *  获取店铺基本信息
 */

const getShopInfo = (shopId, uid) => {

    return searchApi.getShopInfo(shopId, uid).then(result => {
        if (result.code === 200) {
            return {
                brandName: result.data.shop_name,
                brandCont: result.data.shop_intro,
                domain: result.data.shop_domain,
                logo: result.data.shop_logo,
                isFavorite: result.data.is_favorite === 'Y',
                shopTemplateType: result.data.shop_template_type,
                multBrandShopType: result.data.mult_brand_shop_type,
                shopName: result.data.shop_name,
                showShopName: result.data.is_show_shop_name === 'Y'
            };
        } else {
            return {};
        }
    });
};

/**
 * 获取经典模板店铺数据
 * @param shopId
 * @param uid
 * @param params
 * @param shopInfo 店铺介绍
 */
const getShopData = (shopId, channel, params, shopInfo) => {
    let gender = _getGender(channel);

    params = params || {};
    params.shopId = shopId;

    return Promise.all([
        headerModel.requestHeaderData(channel), // 头部数据
        searchApi.getShopDecorator(shopId), // 店铺装修数据
        searchApi.getProductList(Object.assign({
            shop_id: shopId
        }, params)), // 搜索店铺商品
        searchApi.getShopBrands(shopId), // 店铺品牌数据
        shopApi.shopCouponListAsync(shopId) // 店铺优惠券数据
    ]).then(result => {
        let finalResult = {};

        Object.assign(finalResult,
            result[0], // 头部数据
            searchHandler.handlePathNavData(shopInfo, params, 'shop', channel), // 面包屑导航
            searchHandler.getBrandShopSeo(channel, {shopName: shopInfo.shopName || shopInfo.brandName}, params) // 店铺SEO
        );

        _.set(finalResult, 'headerData.header', true);

        // 店铺装修
        if (result[1].code === 200) {
            Object.assign(finalResult, shopHandler.getShopDecorator(result[1].data, params, shopId));

            _.set(finalResult, 'shopTopBanner.brandIntro', {
                shopId: shopId,
                brandName: shopInfo.brandName || '',
                isFavorite: shopInfo.isFavorite || false,
                brandCont: shopInfo.brandCont || ''
            });
        } else {
            return Promise.reject('No ShopDecorator data');
        }

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            let allGoods = {
                name: '全部商品 ALL',
                sort: searchHandler.handleOptsData(params, _.get(result[2], 'data.total', 0)),
                list: productProcess.processProductList(_.get(result[2], 'data.product_list', []), {
                    newCoverSort: true,
                    showDiscount: false,
                    gender: gender
                }),
                href: `/product/shoplist?navBar=1&shopId=${shopId}`
            };

            _.set(allGoods, 'sort.newPage', true); // 启用新的分页导航

            finalResult.allGoods = allGoods;
        }

        let sknList = []; // 资源位配置商品skn
        let prodList = _.concat(_.get(finalResult, 'newArrivel.list', []),
            _.get(finalResult, 'hotSingle.list', []));

        _.forEach(prodList, value => {
            sknList.push(value.productSkn);
        });

        let shopBrandIds = [], // 店铺的所有品牌id
            articleApiMethod = [], // 通过品牌获取相关文章接口
            apiMethod = [
                searchApi.getProductList({
                    viewNum: sknList.length,
                    query: _.join(_.uniq(sknList), ',')
                })
            ];

        if (result[3].code === 200 && result[3].data) {
            _.forEach(result[3].data, value => {
                shopBrandIds.push(value.brand_id);
                articleApiMethod.push(
                    searchApi.getArticleByBrand(value.brand_id, 'udid') // 品牌推荐文章
                );
            });
        }

        if (result[4].data && !_.isEmpty(result[4].data)) {
            finalResult.coupon = searchHandler.handleBrandShopCoupons(result[4].data, {shopId: shopId});
        }

        // 根据品牌获取分类 (腾讯云测试没有该接口，暂时不调用分类)
        apiMethod.push(searchApi.getSortList({brand: shopBrandIds}));
        apiMethod = _.concat(apiMethod, articleApiMethod);

        return Promise.all(apiMethod).then(subRes => {
            // 设置资源位商品封面图
            if (subRes[0].code === 200) {
                let list = {};

                prodList = productProcess.processProductList(_.get(subRes[0], 'data.product_list', []), {
                    newCoverSort: true,
                    showDiscount: false,
                    gender: gender
                });

                _.forEach(prodList, value => {
                    list[value.product_skn] = {
                        img: helpers.getForceSourceUrl(value.default_images) +
                        '?imageView2/1/w/{width}/h/{height}',
                        title: value.product_name,
                        price: `¥${value.sales_price}`
                    };
                });

                if (_.has(finalResult, 'newArrivel.list')) {
                    _.forEach(finalResult.newArrivel.list, value => {
                        if (list[value.productSkn]) {
                            Object.assign(value, list[value.productSkn]);
                        }
                    });
                }

                if (_.has(finalResult, 'hotSingle.list')) {
                    _.forEach(finalResult.hotSingle.list, value => {
                        if (list[value.productSkn]) {
                            Object.assign(value, list[value.productSkn]);
                        }
                    });
                }
            }

            if (subRes[1].code === 200) {
                let groupSort = _.get(subRes[1], 'data.sort', []);

                finalResult.leftContent = searchHandler.handleSortData(groupSort, params);

                if (finalResult.allGoods) {
                    Object.assign(finalResult.allGoods, searchHandler.setShopSort(groupSort, Object.assign({},
                        params, {page: 1})));
                }
            }

            let articleList = [];

            for (let i = 2; i < subRes.length; i++) {
                articleList = _.concat(articleList, _.get(subRes[i], 'data', []));
            }

            if (articleList.length >= 3) {
                let trendList = [];

                for (let i = 0; i < 3; i++) {
                    trendList.push({
                        href: helpers.urlFormat(`/${articleList[i].id}.html`, '', 'guang'),
                        src: helpers.getForceSourceUrl(articleList[i].src) +
                            '?imageView2/1/w/{width}/h/{height}',
                        mainTitle: articleList[i].title,
                        Subtitle: articleList[i].intro
                    });
                    articleList = _.concat(articleList, _.get(subRes[i], 'data', []));
                }

                finalResult.trendInfo = {
                    name: '潮流资讯 HOT ITEMS',
                    trendList: trendList
                };
            }

            return finalResult;
        });
    });
};

/**
 * 获取店铺商品数据
 */
const getShopGoodsData = (shopId, channel, params) => {
    let gender = _getGender(channel);
    let resData = {};

    _.unset(params, '_pjax');
    return Promise.all([
        searchApi.getProductList(Object.assign({
            shop_id: shopId
        }, params)), // 搜索店铺商品
        searchApi.getShopBrands(shopId) // 店铺品牌数据
    ]).then(result => {
        // 获取商品数据和顶部筛选条件
        if (result[0].code === 200) {
            Object.assign(resData, {
                sort: searchHandler.handleOptsData(params, _.get(result[0], 'data.total', 0)),
                list: productProcess.processProductList(_.get(result[0], 'data.product_list', []), {
                    newCoverSort: true,
                    showDiscount: false,
                    gender: gender
                })
            });
            _.set(resData, 'sort.newPage', true); // 启用新的分页导航
        }

        let shopBrandIds = []; // 店铺的所有品牌id

        if (result[1].code === 200 && result[1].data) {
            _.forEach(result[1].data, value => {
                shopBrandIds.push(value.brand_id);
            });
        }

        // 根据品牌获取分类 (腾讯云测试没有该接口，暂时不调用分类)
        return searchApi.getSortList({brand: shopBrandIds}).then(subRes => {
            if (subRes.code === 200) {
                let groupSort = _.get(subRes, 'data.sort', []);

                Object.assign(resData, searchHandler.setShopSort(groupSort, Object.assign(params,
                    {page: 1})));
            }

            return resData;
        });
    });
};

const getShopListData = (channel, params, uid) => {
    let gender = _getGender(channel),
        shopId = params.shopId,
        navBar = params.navBar || 1;
    let apiArr = [
        headerModel.requestHeaderData(channel), // 头部数据
        searchApi.getShopDecorator(shopId), // 店铺装修数据
        searchApi.getShopInfo(shopId, uid), // 店铺介绍
        searchApi.getProductList(Object.assign({shop_id: shopId}, params)), // 搜索店铺商品
        searchApi.getShopBrands(shopId) // 店铺品牌数据
    ];

    if (_.has(params, 'query')) {
        apiArr.push(searchApi.getProductList(Object.assign({shop_id: shopId},
            params, {query: ''}))); // 搜索店铺所有商品
    }


    return Promise.all(apiArr).then(result => {
        let finalResult = {
            headerData: Object.assign(result[0].headerData, {header: true})
        };

        // 面包屑导航
        Object.assign(finalResult, searchHandler.handlePathNavData({}, params, 'shop', channel));

        // 店铺装修
        if (result[1].code === 200) {
            Object.assign(finalResult, shopHandler.getShopDecorator(result[1].data, params, shopId));

            // 设置shop nav选中状态
            _.set(finalResult, `navigationBar[${navBar}].current`, true);

            if (result[2].code === 200) {
                let data = _.get(result[2], 'data', {});

                _.set(finalResult, 'shopTopBanner.brandIntro', {
                    shopId: shopId,
                    brandName: data.shop_name || '',
                    isFavorite: data.is_favorite === 'Y',
                    brandCont: data.shop_intro || ''
                });

                // 店铺SEO
                Object.assign(finalResult, searchHandler.getBrandShopSeo(channel, {
                    shopName: data.shop_name
                }, params));
            }
        } else {
            return Promise.reject('No ShopDecorator data');
        }

        // 获取商品数据和顶部筛选条件
        if (result[3].code === 200) {
            let info = result[3];
            let goodsList = _.get(info, 'data.product_list', []);

            if (goodsList.length) {
                let tip = {
                    start: (_.get(info, 'data.page', 1) - 1) * limitNum + 1,
                    total: _.get(info, 'data.total', 0)
                };

                tip.end = tip.start + limitNum - 1;
                if (tip.end > tip.total) {
                    tip.end = tip.total;
                }

                Object.assign(finalResult, {
                    filters: searchHandler.handleFilterDataAll(info.data, params),
                    opts: searchHandler.handleOptsData(params, tip.total),
                    goods: productProcess.processProductList(goodsList, {
                        newCoverSort: true,
                        showDiscount: false,
                        gender: _getGender(channel),
                        query: params.query
                    }),
                    footPager: {tip: tip}
                });

                _.set(finalResult, 'filters.checkedConditions.clearUrl',
                    `?navBar=${params.navBar}&shopId=${params.shopId}`);
            } else {
                finalResult.searchEmpty = true;

                if (result[5] && result[5].code === 200) {
                    let allGoods = {
                        name: '全部商品 ALL',
                        sort: searchHandler.handleOptsData(params, _.get(result[5], 'data.total', 0)),
                        list: productProcess.processProductList(_.get(result[5], 'data.product_list', []), {
                            newCoverSort: true,
                            showDiscount: false,
                            gender: gender
                        })
                    };

                    _.set(allGoods, 'sort.newPage', true); // 启用新的分页导航

                    finalResult.allGoods = allGoods;
                }
            }
        }

        if (result[4].code === 200) {
            let shopBrandIds = []; // 店铺下的所有品牌id数组

            _.forEach(_.get(result[4], 'data', []), value => {
                shopBrandIds.push(value.brand_id);
            });

            return searchApi.getSortList({brand: shopBrandIds}).then(subRes => {
                if (subRes.code === 200) {
                    let groupSort = _.get(subRes, 'data.sort', []),
                        noPageQs = Object.assign({}, params, {page: 1});

                    finalResult.leftContent = searchHandler.handleSortData(groupSort, noPageQs);

                    if (finalResult.allGoods) {
                        Object.assign(finalResult.allGoods, searchHandler.setShopSort(groupSort, noPageQs));
                    }
                }

                return finalResult;
            });

        }

        finalResult.criteo = {skn: searchHandler.getCriteo(_.get(finalResult, 'goods'))};

        return finalResult;
    });
};

/**
 * 获取基础模板店铺数据
 */
const getBaseShopData = (params, extra, channel, shopId) => {
    let resData = {};

    return Promise.all([
        getBrandData(params, extra, channel),
        searchApi.getShopDecorator(shopId), // 店铺装修数据
        searchApi.getShopInfo(shopId, extra.uid),
        shopApi.shopCouponListAsync(shopId) // 店铺优惠券数据
    ]).then(result => {
        let brand = result[0] || {};

        Object.assign(resData, brand);

        if (result[1].code === 200) {
            let data = result[1].data || {},
                decorator = shopHandler.getShopDecorator(data, {}, shopId, true);

            Object.assign(decorator.shopTopBannerBase, {
                shopId: shopId,
                bannerHeight: 150,
                shopHome: `/?shopId=${shopId}`,
                shopIntro: `/about?shopId=${shopId}`,
                coled: _.get(result[2], 'data.is_favorite', 'N') === 'Y'
            });

            _.set(resData, 'brand.shopBanner', decorator.shopTopBannerBase);
            _.unset(resData, 'brand.brandBanner');

            if (decorator.signboard) {
                _.unset(resData, 'brand.node');
                _.set(resData, 'brand.signboard', decorator.signboard);
            }
        }

        if (result[2].code === 200) {
            let shopName = _.get(result[2], 'data.shop_name', '');

            _.set(resData, 'brand.shopBanner.shopName', shopName);
            _.set(resData, 'brand.pathNav[2]', {
                name: shopName,
                pathTitle: shopName
            });

            // 店铺SEO
            Object.assign(resData, searchHandler.getBrandShopSeo(channel, {
                shopName: shopName
            }, params));
        }

        _.unset(resData, 'brand.coupon');
        if (result[3].data && !_.isEmpty(result[3].data)) {
            _.set(resData, 'brand.coupon',
                searchHandler.handleBrandShopCoupons(result[3].data, {shopId: shopId}));
        }

        // 临时删除seo信息
        _.unset(resData, 'title');
        _.unset(resData, 'keywords');
        _.unset(resData, 'description');

        return resData;
    });
};

const getUserCoupunStatus = (id, uid, type) => {
    if (type === 'shop') {
        return shopApi.shopCouponListAsync(id, uid).then(result => {
            if (result.data) {
                _.forEach(result.data, value => {
                    Object.assign(value, {
                        coupon_id: crypto.encryption('', `${value.coupon_id}`),
                        money: +value.money
                    });
                });
            }

            return result;
        });
    } else {
        return searchApi.getBrandCouponAsync(id, uid).then(result => {
            if (result.data) {
                result.data = _.get(result, 'data.coupons', []);
                _.forEach(result.data, value => {
                    Object.assign(value, {
                        coupon_id: crypto.encryption('', `${value.coupon_id}`),
                        money: +value.money
                    });
                });
            }

            return result;
        });
    }

};

module.exports = {
    getListData,
    getListNewData,
    getBrandInfo,
    getBrandData,
    getBrandAbout,
    getShopAbout,
    getNodeContentData,
    getAdnav,
    getShopInfo,
    getShopData,
    getShopGoodsData,
    getShopListData,
    getBaseShopData,
    getUserCoupunStatus
};