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

'use strict';
const utils = '../../../utils';
const searchApi = require('./search-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 _ = require('lodash');

const limitNum = 60; // 商品每页显示数目

// 品牌页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;
};

/**
 * 获取商品分类列表数据
 */
exports.getListData = (params, channel) => {
    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(channel),
        searchApi.getSortList(),
        searchApi.getProductList(params)
    ];

    // 搜索分类介绍和广告
    if (params.msort && 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) {
            finalResult.list = Object.assign(searchHandler.handlePathNavData(result[1].data.sort, params, 'sort'), {
                leftContent: searchHandler.handleSortData(result[1].data.sort, params)
            });
        }

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            Object.assign(finalResult.list, {
                // filters: searchHandler.handleFilterData(result[2].data.filter, params),
                filters: searchHandler.handleFilterDataAll(result[2].data, params),
                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))
            });
        }

        // 分类介绍
        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));
        }

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

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

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

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

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

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

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            Object.assign(finalResult.list, {
                // filters: searchHandler.handleFilterData(result[2].data.filter, params),
                filters: searchHandler.handleFilterDataAll(result[2].data, params),
                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))
            });
        }

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

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

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

/**
 * 根据品牌域名查询品牌信息
 */
exports.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
        };

    });
};

/**
 * 获取品牌页面数据
 */
exports.getBrandData = (params, extra, channel) => {

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

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(channel),
        searchApi.getSortList({brand: extra.brandId}),
        searchApi.getProductList(Object.assign({order: order, brand: extra.brandId}, params))

    ];

    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 || ''
            }
        };

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

        // 获取商品数据和顶部筛选条件
        if (result[2].code === 200) {
            Object.assign(finalResult.brand, {
                filters: searchHandler.handleFilterDataAll(result[2].data, params),
                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))
            });
        }

        // 品牌页不显示品牌筛选项
        delete finalResult.brand.filters.brand;

        let seo = searchHandler.getBrandSeo(channel, extra);

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

/**
 * 获取品牌页面数据
 */
exports.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;

    });

};

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

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

/**
 * 获取品牌页面系列
 */
exports.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.handleFolderData(result[0].data));
        }


        return dest;
    });
};

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

exports.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,
                showShopName: result.data.is_show_shop_name === 'Y'
            };
        } else {
            return {};
        }
    });
};

/**
 * 获取经典模板店铺数据
 * @param shopId
 * @param uid
 * @param params
 * @param shopInfo 店铺介绍
 */
exports.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) // 店铺品牌数据
    ]).then(result => {
        let finalResult = {};

        Object.assign(finalResult,
            result[0], // 头部数据
            searchHandler.handlePathNavData(shopInfo, params, 'shop') // 面包屑导航
        );

        _.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({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') // 品牌推荐文章
                );
            });
        }

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

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

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

                _.forEach(prodList, value => {
                    coverList[value.productSkn] = value.defaultImages;
                });

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

                if (_.has(finalResult, 'hotSingle.list')) {
                    _.forEach(finalResult.hotSingle.list, value => {
                        if (coverList[value.productSkn]) {
                            value.img = coverList[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, params));
                }
            }

            return finalResult;
        });
    });
};

exports.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'));

        // 店铺装修
        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 || ''
                });
            }
        } 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)
                    }),
                    footPager: {tip: tip}
                });
            } 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', []);

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

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

                return finalResult;
            });

        }

        return finalResult;
    });
};

/**
 * 获取基础模板店铺数据
 */
exports.getBaseShopData = (shopId, uid) => {
    return searchApi.getShopInfo(shopId, uid);
};