/**
 * 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 stringCode = require(`${utils}/string-code`);
const _ = require('lodash');
const logger = global.yoho.logger;
const api = global.yoho.API;
const cache = require('memory-cache');
const helpers = global.yoho.helpers;
const redis = require(`${utils}/redis`);
const co = require('bluebird').coroutine;

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

/**
 * 品牌名称处理
 * @param  {[object]} list
 * @return {[object]}
 */
const _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]}
 */
const _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;
};

/**
 * 商品搜索接口请求
 * TODO 按接口拆分
 * @param  {[object]} params
 * @return {[array]}
 */
const _searchGoods = (params) => {
    let method = 'app.search.li';

    if (_.isArray(params.query)) {
        params.query = _.join(params.query, ',');
    }

    // 排除基本筛选项默认值为0的对象
    for (let str in params) {
        if (str !== 'order' && params[str] === '0' || params[str] === null) {
            delete params[str];
        }
    }

    /* tar add 160823 店铺销售类目 */
    if (params.filter_poolId) {
        method = 'app.search.pool';
        Object.assign(params, {
            productPool: params.filter_poolId
        });
        delete params.filter_poolId;
    }

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

    if (params.channel) {
        params.yh_channel = searchProcess.getChannelType(params.channel);
        delete params.channel;
    }

    if (params.query) {
        params.query = params.query.replace(/\+/g, ',');
    }

    if (params.app_type && params.app_type === '1') {
        params.app_type = 1;
    }

    params = _.assign({
        limit: '24',
        status: 1,
        sales: 'Y',
        stocknumber: 1,
        attribute_not: 2
    }, params);

    if (params.type === 'default') {
        // 筛选 默认 不传order
        delete params.order;
    } else if (params.order) {
        params.order = searchProcess.getTypeCont(params.type || '', params.order);
    } else {
        params.order = 's_t_asc';
    }

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

        if (params.type === 'newest') {
            delete params.order;
            delete params.type;
        }
    }

    if (params.isblknew) {
        method = 'app.search.newProduct';
        params.app_type = 1;
        if (params.type === 'default') {
            params.order = 's_t_asc';
        }
    }

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

    if (params.students) {
        method = 'app.student.discount';
    }

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

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

    return api.get('', _.assign({
        method: method
    }, params), {
        cache: true
    });
};

/**
 * 获取店铺列表
 */
const _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;
};

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

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

    return _searchGoods(params).then((result) => {
        if (result && result.code === 200) {
            let newList = {};
            let suggestion = {};

            if (result.data.shopList && result.data.shopList.length !== 0) {
                newList.brandWay = _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 [];
        }
    });
};

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

    finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
    return api.get('', finalParams);
};

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

    finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
    return api.get('', finalParams);
};

/**
 * 搜索店铺的商品
 */
const getShopGoods = (params) => {
    let finalParams = {
        method: 'app.search.shop',
    };

    finalParams = _.assign(finalParams, searchProcess.getSearchParamsWithoutMethod(params));
    return api.get('', finalParams);
};

/**
 * 获取筛选数据
 */
const getFilterData = (params) => {
    return co(function* () {
        let filterDataResult = {};

        if (params.isShopBrand === 'Y') { // 店铺之品牌
            filterDataResult = yield getBrandGoods(params);
        } else if (params.isShopList === 'Y') { // 无店铺有店铺 ID 的商品列表
            filterDataResult = yield getShopGoods(params);
        } else {
            filterDataResult = yield _searchGoods(params);
        }

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

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

/**
 * 获取筛选数据
 * @param  {[object]} params
 * @return {[array]}
 * TODO 这个可能不用了，待确定
 */
const getFilterSearchData = (params) => {
    return _searchGoods(params).then((result) => {
        if (result && result.code === 200) {
            return result.data;
        } else {
            logger.error('get filter data api return code is not 200');
            return [];
        }
    });
};

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

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

/**
 * 搜索主页
 */
const 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 api.get('', _.assign({
        method: 'app.search.getTerms'
    }, params), {
        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>}
 */
const getFuzzyDatas = (params) => {
    return api.get('', {
        method: 'app.search.fuzzy',
        keyword: params
    }, {
        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>}
 */
const searchKeyActivity = (params) => {
    return api.get('', {
        method: 'app.search.word',
        query: params
    }, {
        cache: true,
        code: 200
    }).then(result => {
        if (result && result.data) {
            return result.data;
        } else {
            return {};
        }
    });
};

/**
 * 检查字符串是否是品牌域/品牌名称
 *
 * @param query
 * @returns {*|Promise.<TResult>}
 */
const 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 getAllBrandNames().then(fn);
    }
};


const getSearchKeywordData = (params, uid) => {

    // 获取第一页数据做服务端渲染
    let initialData = _.assign({
        type: 'default',
        order: '0',
        page: 1,
        limit: 24
    }, params);

    if (uid) {
        initialData.uid = uid;
    }

    return Promise.all([
        getFuzzyDatas(`${params.query}`.substr(0, 2)),
        getSearchData(initialData)
    ]).then(result => {
        let fuzzy = [];

        if (_.isEmpty(result[0])) {
            result[0] = [];
        }

        _.forEach(_.slice(result[0], 0, 12), value => {
            if (value.keyword === params.query) {
                return;
            }

            fuzzy.push({
                name: value.keyword,
                link: helpers.urlFormat(`/so/${stringCode.utf8ToHex(value.keyword)}.html`),
            });
        });

        if (!_.isEmpty(fuzzy)) {
            result[1].fuzzyWord = fuzzy;
        }

        return result[1];
    });
};

const getSearchKeywordDataById = (id, params, uid) => {
    return redis.all([
        ['get', `global:yoho:seo:keywords:id:${id}`]
    ]).then(redisData => {
        if (!redisData[0]) {
            return false;
        }

        redisData = JSON.parse(redisData[0]);
        params.query = redisData.name;

        return getSearchKeywordData(params, uid).then(result => {
            result.queryKey = params.query;

            if (!_.isEmpty(redisData.data)) {
                let tdata = _.slice(redisData.data, 0, 12);

                _.forEach(tdata, value => {
                    if (!value) {
                        return;
                    }

                    Object.assign(value, {
                        name: value.keyword,
                        link: helpers.urlFormat(`/chanpin/${value.id}.html`, null)
                    });
                });

                _.set(result, 'fuzzyWord', redisData.data);
            }

            return result;
        });
    });
};

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

module.exports = {
    getSearchData,
    getFilterData,
    getFilterSearchData,
    getAllBrandNames,
    getClassNames,
    getSearchIndex,
    getFuzzyDatas,
    searchKeyActivity,
    getBrandDomain,
    getSearchKeywordData,
    getSearchKeywordDataById,
    getSearchGoods,
    getBrandGoods,
    getShopGoods,
    searchProductBySkn
};