/*
 * @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;

/**
 * 获取商品分类列表数据
 */
exports.getListData = (params) => {
    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(),
        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 = {
                leftContent: searchHandler.handleSortData(result[1].data.sort, params),
                pathNav: searchHandler.handlePathNavData(result[1].data.sort, params, 'sort')
            };
        }

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

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

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(),
        searchApi.getSortList(),
        searchApi.getProductList(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 = {
                leftContent: searchHandler.handleSortData(result[1].data.sort, params),
                pathNav: searchHandler.handlePathNavData(result[1].data.sort, params, 'new')
            };
        }

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

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

        return 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) => {

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

    // 调用接口
    let apiMethod = [
        headerModel.requestHeaderData(),
        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.handleFilterData(result[2].data.filter, 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 (finalResult.list && finalResult.list.filters) {
                Object.assign(finalResult.list.filters, searchHandler.handleSeniorFilterData({
                    style: _.get(result[2], 'data.filter.style', []),
                    standard: _.get(result[2], 'data.standard', [])
                }, params));
            }
        }

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

        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 {

            // log
        }
    });
};

/**
 * 获取经典模板店铺数据
 * @param shopId
 * @param uid
 * @param params
 * @param shopInfo 店铺介绍
 */
exports.getShopData = (shopId, uid, params, shopInfo) => {
    params = params || {};
    params.shopId = shopId;

    // 店铺所有品牌
    return searchApi.getShopBrands(shopId).then(shopBrands => {
        if (shopBrands.code === 200 && shopBrands.data) {
            return shopBrands.data;
        }
    }).then(shopBrands => {

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

        // 通过品牌获取相关文章接口
            articleApiMethod = [],

        // 需要调用的接口数组
            apiMethod = [

            // 头部数据
                headerModel.requestHeaderData('boys'),

            // 店铺装修数据
                searchApi.getShopDecorator(shopId),

            // 搜索店铺商品
                searchApi.getProductList(params)
            ];

        _.forEach(shopBrands, (value) => {

            shopBrandIds.push(value.brand_id);

            articleApiMethod.push(

                // 店铺装修数据
                searchApi.getArticleByBrand(value.brand_id, 'udid')
            );

        });

        // 根据品牌获取分类 (腾讯云测试没有该接口，暂时不调用分类)
        apiMethod.push(

            // 店铺分类
            searchApi.getSortList({brand: shopBrandIds})
        );

        // apiMethod 添加调用相关文章的接口
        apiMethod = _.concat(apiMethod, articleApiMethod);

        return Promise.all(apiMethod).then(result => {
            let finalResult = {
                headerData: Object.assign(result[0].headerData, {header: true}),
                pathNav: searchHandler.handlePathNavData(shopInfo, params, 'shop')
            };

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

            // 店铺介绍

            // 店铺装修
            if (result[1].code === 200) {
                Object.assign(finalResult, shopHandler.getShopDecorator(result[1].data, params, shopId));
            } 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', []))
                };

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

                finalResult.allGoods = allGoods;
            }

            if (result[3].code === 200) {
                let groupSort = _.get(result[3], 'data.filter.group_sort', []);

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

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

            return finalResult;
        });

    });
};

exports.getShopListData = (params) => {
    let shopId = params.shopId;
    let navBar = params.navBar || 1;

    return searchApi.getShopBrands(shopId).then(shopBrands => {
        if (shopBrands.code === 200 && shopBrands.data) {
            return shopBrands.data;
        }
    }).then(shopBrands => {
        let shopBrandIds = [], // 店铺下的所有品牌id数组
            apiMethod = [
                headerModel.requestHeaderData('boys'), // 头部数据
                searchApi.getShopDecorator(shopId), // 店铺装修数据
                searchApi.getProductList(params) // 搜索店铺商品
            ]; // 需要调用的接口数组

        _.forEach(shopBrands, (value) => {
            shopBrandIds.push(value.brand_id);
        });

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

        return Promise.all(apiMethod).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);
            } else {
                return Promise.reject('No ShopDecorator data');
            }

            // // 获取商品数据和顶部筛选条件
            if (result[2].code === 200) {
                let tip = {
                    start: (_.get(result[2], 'data.page', 1) - 1) * limitNum + 1,
                    total: _.get(result[2], 'data.total', 0)
                };

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

                Object.assign(finalResult, {
                    filters: searchHandler.handleFilterData(_.get(result[2], 'data.filter', {}), params),
                    opts: searchHandler.handleOptsData(params, tip.total),
                    goods: productProcess.processProductList(_.get(result[2], 'data.product_list', [])),
                    footPager: {tip: tip}
                });
                
                // 获取高级筛选条件
                if (finalResult.list && finalResult.list.filters) {
                    Object.assign(finalResult.list.filters, searchHandler.handleSeniorFilterData({
                        style: _.get(result[2], 'data.filter.style', []),
                        standard: _.get(result[2], 'data.standard', [])
                    }, params));
                }
            }

            if (result[3].code === 200) {
                finalResult.leftContent = searchHandler.handleSortData(_.get(result[3],
                    'data.filter.group_sort', []), params);
            }

            return finalResult;
        });

    });

};

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