/**
 * search model
 * @author: wsl<shuiling.wang@yoho.cn>
 * @date: 2016/07/21
 */
'use strict';
const utils = '../../../utils';
const productProcess = require(`${utils}/product-process`);
const searchProcess = require(`${utils}/search-process`);
const _ = require('lodash');
const logger = global.yoho.logger;
const cache = require('memory-cache');
const helpers = global.yoho.helpers;
const co = require('bluebird').coroutine;

/**
 * 封面图
 * @type {{boys: string, gilrs: string}}
 */
const _coverChannel = {
    boys: '1,3',
    gilrs: '2,3'
};

module.exports = class extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
    }

    /**
     * 品牌名称处理
     * @param  {[object]} list
     * @return {[object]}
     */
    _processBrandNames(list) {
        const formatData = [];
        const brandDomainMap = {}, brandNameMap = {};
        const ttl = 60000; // 默认缓存一分钟
        let brandDomain = '';
        let brandName = '';

        list = list || [];

        _.forEach(list, (item) => {
            _.forEach(item, (obj) => {
                brandDomain = obj.brand_domain && obj.brand_domain.toLowerCase();
                brandName = obj.brand_name && obj.brand_name.toLowerCase();

                if (brandDomain && brandName) {
                    formatData.push({
                        brandDomain: brandDomain,
                        brandName: brandName
                    });

                    brandDomainMap[brandDomain] = brandDomain;
                    brandNameMap[brandName] = brandDomain;
                }
            });
        });

        cache.put('brandDomainMap', brandDomainMap, ttl);
        cache.put('brandNameMap', brandNameMap, ttl);

        return formatData;
    }

    /**
     * 品牌名称处理
     * @param  {[object]} list
     * @return {[object]}
     */
    _processClassNames(list) {
        const formatData = {
            first: {},
            second: {}
        };

        list = list || [];

        _.forEach(list, (item) => {
            _.forEach(item, (obj) => {
                formatData.first[obj.category_id] = obj.category_name;

                if (obj.sub) {
                    _.forEach(obj.sub, (sub) => {
                        formatData.second[sub.category_id] = sub.category_name;
                    });
                }

            });
        });

        return formatData;
    }

    /**
     * 获取店铺列表
     */
    _processBrandShops(list) {
        let formatDat = [];

        _.forEach(list, item => {
            if (item.shop_type === 'yoho_shop') {
                formatDat.push({
                    url: helpers.urlFormat('/product/shop', {
                        shop_id: item.shop_id
                    }),
                    thumb: helpers.image(item.shop_logo, 126, 80),
                    name: item.shop_name,
                    shopId: item.shop_id
                });
            } else if (item.shop_type === 'tbl_brand') {
                formatDat.push({
                    url: helpers.urlFormat('/product/global/list/', {
                        brand: item.global_brand_id
                    }),
                    thumb: helpers.image(item.brand_ico, 126, 80),
                    name: item.brand_name,
                    brandId: item.global_brand_id
                });
            }
        });

        if (formatDat.length > 2) {
            formatDat.moreShop = true;
        }

        return formatDat;
    }

    /**
     * 获取商品数据
     */
    getSearchData(params) {

        // client_type 全部赋值为h5 过滤掉嵌入APP页面是默认的client_type
        params.client_type = 'h5';

        return this.getCategoryGoods(params, true).then((result) => {
            if (result && result.code === 200) {
                let newList = {};
                let suggestion = {};

                if (result.data.shopList && result.data.shopList.length !== 0) {
                    newList.brandWay = this._processBrandShops(result.data.shopList);
                }

                newList.list = productProcess.processProductList(result.data.product_list || [], {
                    isApp: params.isApp || (params.appVersion && params.appVersion !== 'false'),
                    gender: _coverChannel[params.coverChannel],
                    showSimilar: params.shop_id || params.material === 'true' ? false : true
                });
                if (params.unionType && (params.material === 'true')) {
                    _.forEach(newList.list, (val) => {
                        let newUrl = val.url;

                        val.url = newUrl.replace('.html', `.html?union_type=${params.unionType}`);
                    });
                }

                if (result.data.rec_shop_list && result.data.rec_shop_list.length > 0 &&
                    !params.shop_id && !params.brand && !params.isApp) {

                    for (let i = 0; i < result.data.rec_shop_list.length; i++) {
                        if (parseInt(result.data.rec_shop_list[i].show_type, 10) === 1) {
                            result.data.rec_shop_list[i].is_shop = true;
                            result.data.rec_shop_list[i].shopUrl = '//m.yohobuy.com/product/shop?domain=' +
                                result.data.rec_shop_list[i].shop_domain;
                            newList.list.splice(parseInt(result.data.rec_shop_list[i].insert_index, 10) - 1, 0,
                                result.data.rec_shop_list[i]);
                        }
                    }
                }

                params.page = parseInt(params.page, 10);
                result.data.total = parseInt(result.data && result.data.total || 0, 10);

                if (params.page === 1) {
                    newList.total = result.data.total;
                }

                // 搜索过来的  推荐词条件判断 redmine: 18567
                if (params.from === 'search' && params.page === 1 && (result.data.isChangedQuery === 'Y' ||
                    result.data.total < 20 || params.needSuggestion === 'Y')) {

                    params.isChangedQuery = result.data.isChangedQuery === 'Y';

                    suggestion = {
                        isNeedSuggestion: params.isChangedQuery || params.needSuggestion === 'Y', // 是否是关键词搜索判断
                        termsSuggestion: productProcess.termsSuggestion(
                            result.data.suggestion && result.data.suggestion.terms_suggestion || [], params
                        ),
                        isMaybeLike: result.data.total < 20, // 搜索过来的 小于 20条 猜你喜欢显示不显示判断
                        showSimilar: true
                    };
                    suggestion.isNeedSuggestionOne = suggestion.termsSuggestion.length > 1;// 如果只有一个<或者试试不显示>
                }
                newList.suggestion = suggestion;

                return newList;
            } else {
                logger.error('get product search api return code is not 200');
                return [];
            }
        });
    }

    /**
     * 获取品类下的商品列表
     * @param isSearch 是否是搜索列表页
     * 搜索列表页默认调用 app.search.li 接口
     * 类目列表页默认调用 web.search.search 接口
     */
    getCategoryGoods(params, isSearch) {
        let method = isSearch ? 'app.search.li' : 'web.search.search';

        if (params.filter_poolId) {
            method = 'app.search.pool';
        }

        if (params.shop_id && !params.filter_poolId && !params.productPool) {
            method = 'app.search.li';
        }

        // 个人中心优惠券立即使用 - 商品列表
        if (params.coupon_id || params.coupon_code) {
            method = 'app.search.coupon';
        }

        // 物料商品列表增加
        if (params.material === 'true') {
            method = 'app.search.recommendProduct';
        }

        if (params.isblknew) {
            method = 'app.search.newProduct';
        }

        if (params.promotion_id) {
            method = 'app.search.promotion';
        }

        // 学生优惠
        if (params.students) {
            method = 'app.student.discount';
        }

        // 学生返币查询
        if (params.coin) {
            method = 'app.student.rebate';
        }

        // 促销活动
        if (params.specialsale_id) {
            method = 'app.search.li';
        }

        if (method === 'web.search.search') {
            params.from = 'categoryList';
        }

        let paramsForApi = searchProcess.getSearchParamsWithoutMethod(params);

        return this.get({
            data: _.assign({}, paramsForApi, {
                method: method
            })
        });
    }

    /**
     * 模糊搜索，获取商品数据
     */
    getSearchGoods(params) {
        let finalParams = {
            method: 'app.search.li',
        };

        finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
        return this.get({
            data: finalParams
        });
    }

    /**
     * 搜索品牌的商品
     */
    getBrandGoods(params) {
        let finalParams = {
            method: 'app.search.brand',
        };

        finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
        return this.get({
            data: finalParams
        });
    }

    /**
     * 搜索店铺的商品
     */
    getShopGoods(params) {
        if (!/^[0-9]*$/.test(params.shop_id)) {
            return Promise.resolve({});
        }

        let finalParams = {
            method: 'app.search.shop',
        };

        finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
        return this.get({
            data: finalParams
        });
    }

    /**
     * 获取筛选数据
     */
    getFilterData(params) {
        let self = this;

        return co(function* () {
            let filterDataResult = {};

            if (params.isShopBrand === 'Y') { // 店铺之品牌
                filterDataResult = yield self.getBrandGoods(params);
            } else if (params.isShopList === 'Y') { // 无店铺有店铺 ID 的商品列表
                filterDataResult = yield self.getShopGoods(params);
            } else { // 新的 SEO 友好的品类落地页
                filterDataResult = yield self.getCategoryGoods(params);
            }

            let filterData = _.get(filterDataResult, 'data.filter', []);

            if (filterData) {
                return productProcess.processFilter(filterData);
            } else {
                return [];
            }
        })();
    }

    /**
     * 获取所有的品类名称
     **/
    getClassNames() {
        return this.get({
            data: {
                method: 'app.sort.get'
            },
            param: {
                cache: true
            }
        }).then((result) => {
            if (result && result.code === 200) {
                return this._processClassNames(result.data);
            } else {
                logger.error('get category name api return code is not 200');
                return {};
            }
        });
    }

    /**
     * 获取所有的品牌名称
     **/
    getAllBrandNames() {
        return this.get({
            data: {
                method: 'app.brand.brandlist'
            },
            param: {
                cache: true
            }
        }).then((result) => {
            if (result && result.code === 200) {
                return this._processBrandNames(result.data.brands);
            } else {
                logger.error('get brand all name data api return code is not 200');
                return {};
            }
        });
    }

    /**
     * 搜索主页
     */
    getSearchIndex(params) {
        let channels = {
            boys: 1,
            girl: 2,
            kids: 3,
            lifestyle: 4
        };

        if (params.gender && channels[params.gender]) {
            params.yh_channel = channels[params.gender];
            delete params.gender;
        }

        return this.get({
            data: _.assign({
                method: 'app.search.getTerms'
            }, params),
            param: {
                cache: true
            }
        }).then((result) => {
            if (result && result.code === 200) {
                if (result.data.hotTerms && result.data.hotTerms.length > 10) {
                    result.data.hotTerms = result.data.hotTerms.slice(0, 10);
                }

                if (result.data.guessTerms && result.data.guessTerms.length > 10) {
                    result.data.guessTerms = result.data.guessTerms.slice(0, 10);
                }

                return result.data;
            } else {
                logger.error('Hot Search return code is not 200');
                return {};
            }
        });
    }

    /**
     * 获取联想词
     * @param params
     * @returns {*|Promise.<TResult>}
     */
    getFuzzyDatas(params) {
        return this.get({
            data: {
                method: 'app.search.fuzzy',
                keyword: params
            },
            param: {
                cache: true
            }
        }).then((result) => {
            if (result && result.code === 200) {
                return result.data;
            } else {
                logger.error('FuzzyDatas return code is not 200');
                return {};
            }
        });
    }

    /**
     * 查询关键词是否正参加活动
     * @param params
     * @returns {*|Promise.<TResult>}
     */
    searchKeyActivity(params) {
        return this.get({
            data: {
                method: 'app.search.word',
                query: params
            },
            param: {
                cache: true,
                code: 200
            }
        }).then(result => {
            if (result && result.data) {
                return result.data;
            } else {
                return {};
            }
        });
    }

    /**
     * 检查字符串是否是品牌域/品牌名称
     *
     * @param query
     * @returns {*|Promise.<TResult>}
     */
    getBrandDomain(query) {
        let brandDomainMap = cache.get('brandDomainMap');
        let brandNameMap = cache.get('brandNameMap');

        const fn = () => {
            brandDomainMap = cache.get('brandDomainMap');
            brandNameMap = cache.get('brandNameMap');

            let ret = null;

            if (!_.isEmpty(brandDomainMap) && brandDomainMap.hasOwnProperty(query)) {
                ret = brandDomainMap[query] || null;
            }

            if (!_.isEmpty(brandNameMap) && brandNameMap.hasOwnProperty(query)) {
                ret = brandNameMap[query] || null;
            }

            return Promise.resolve(ret);
        };

        if (brandDomainMap && brandNameMap) {
            logger.debug('Using cached brand data.');
            return fn();
        } else {
            logger.debug('Reloading brand data...');
            return this.getAllBrandNames().then(fn);
        }
    }

    /**
     * 通过 skn 搜索商品
     * @param productSkn
     * @returns {*|Promise.<TResult>}
     * @private
     */
    searchProductBySkn(productSkn) {
        return this.get({
            data: {
                method: 'h5.product.batch',
                productSkn: productSkn
            },
            param: {code: 200, cache: true}
        }).then(result => {
            return _.get(result, 'data.product_list', []);
        });
    }
};