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

'use strict';
const utils = '../../../utils';
const api = global.yoho.API;
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');

// 品牌页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 api.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 (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 api.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 (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 api.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))
            });
        }

        // 品牌页不显示品牌筛选项
        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 api.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) => {

    // 店铺所有品牌
    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 api.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[1].code === 200) {
            //     Object.assign(finalResult.shop, {
            //         leftContent: searchHandler.handleSortData(result[1].data.sort, params),
            //         pathNav: searchHandler.handlePathNavData(extra, params, 'brand')
            //     });
            // }

            // if (result[1].code === 200) {

            //     console.log(result[1].data);
            // }

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

    });
};

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