/**
 * Created by TaoHuang on 2016/6/14.
 */
'use strict';
const _ = require('lodash');
const Fn = require('lodash/fp');
const md5 = require('md5');

const api = global.yoho.API;
const serviceApi = global.yoho.ServiceAPI;
const config = global.yoho.config;

const helpers = global.yoho.helpers;
const cache = global.yoho.cache;
const logger = global.yoho.logger;

const getSortByConditionAsync = (condition) => {
    return api.get('', Object.assign({
        method: 'web.regular.groupsort'
    }, condition), config.apiCache);
};

// 判断用户是否收藏品牌
const isFavoriteBrandUrl = '/shops/service/v1/favorite/getUidBrandFav';

// 根据品牌查询相关文章
const relateArticleUrl = 'guang/service/v2/article/getArticleByBrand';

// 缓存生效时间
const CACHE_TIME_S = 60;

const getSearchCacheKey = params => {
    let removeUnusedKey = Fn.omit(['page', 'limit', 'need_filter', 'order']);
    let sortByKey = Fn.pipe(Fn.toPairs, Fn.sortBy(0), Fn.flatten);
    let genKey = Fn.pipe(Fn.cloneDeep, removeUnusedKey, sortByKey, Fn.join('_'));

    return 'search_custom_' + md5(genKey(params));
};

const saveCache = (key, kv, cacheTime) => {
    cache.set(key, kv, cacheTime)
         .catch(err => logger.debug(`product query save cache data fail:${err.toString()}`));
};

const getProductListOrig = finalParams => api.get('', finalParams);

const getKeyActivityAsync = (query) => {
    return api.get('', {
        method: 'app.search.word',
        query: query
    }, {
        catch: true,
        code: 200
    });
};

/**
 * 获取商品列表
 * @return
 */
const getProductList = (params, from) => {
    let finalParams = {
        method: 'web.search.search',
        sales: 'Y',
        outlets: 2,
        stocknumber: 1,
        need_filter: 'yes',
        limit: 60
    };

    Object.assign(finalParams, params);

    // 店铺默认排序s_w_desc
    if (params.shopId || params.shop_id || params.shop) {
        finalParams.order = params.order || 's_w_desc';
    }

    if (from) {
        finalParams.from = from;
    }

    if (!config.useCache) {
        return getProductListOrig(finalParams);
    } else {
        let cKey = getSearchCacheKey(finalParams);

        return cache.get(cKey)
                    .catch(err => logger.debug(`product query save cache data fail:${err.toString()}`))
                    .then(cdata => {
                        let hasCache = false;

                        if (cdata) {

                            try {
                                cdata = JSON.parse(cdata);
                            } catch (e) {
                                logger.debug('getProductList cache data parse fail.');
                            }

                            if (cdata.filter && cdata.standard) {
                                hasCache = true;
                                finalParams.need_filter = 'no';
                            }
                        }

                        return getProductListOrig(finalParams).then(result => {
                            if (hasCache && result && result.data) {
                                Object.assign(result.data, cdata);
                            } else {
                                if (result && result.data && result.data.filter) {
                                    saveCache(cKey, Object.assign({}, {
                                        filter: result.data.filter,
                                        standard: result.data.standard
                                    }), CACHE_TIME_S);
                                }
                            }

                            return result;
                        });
                    });
    }
};

const getSortListOrig = (finalParams) => api.get('', finalParams, config.apiCache);

/**
 * 获取分类列表
 * @return
 */
const getSortList = (params) => {
    let finalParams = {
        method: 'web.regular.groupsort',
        sales: 'Y', // 在销售商品分类
        status: 1, // 上架商品分类
        stocknumber: 1 // 过滤掉已售罄
    };

    Object.assign(finalParams, params);

    if (!config.useCache) {
        return getSortListOrig(finalParams);
    } else {
        let cKey = getSearchCacheKey(finalParams);

        return cache.get(cKey)
                    .catch(err => logger.debug(`product query save cache data fail:${err.toString()}`))
                    .then(cdata => {
                        let cdataObj;

                        if (cdata) {
                            try {
                                cdataObj = JSON.parse(cdata);
                            } catch (e) {
                                logger.debug('getSortList cache data parse fail.');
                            }
                        }

                        if (cdataObj) {
                            return cdataObj;
                        } else {
                            return getSortListOrig(finalParams).then(ret => {
                                if (ret && ret.code === 200) {
                                    saveCache(cKey, ret, CACHE_TIME_S);
                                }
                                return ret;
                            });
                        }
                    });
    }
};

/**
 * 获取分类图文介绍
 * @return
 */
const getSortIntro = (params) => {
    let finalParams = {
        method: 'web.search.banner'
    };

    Object.assign(finalParams, params);
    return api.get('', finalParams, config.apiCache);
};

/**
 * 获取分类广告
 * @return
 */
const getSortAds = (params) => {
    let finalParams = {
        method: 'app.ads.list'
    };

    Object.assign(finalParams, params);
    return api.get('', finalParams, config.apiCache);
};

/**
 * 获取品牌系列
 * @return
 */
const getBrandShopSeries = (params) => {
    let finalParams = {
        method: 'web.brand.series',
        status: params.status || 1
    };

    if (params.brandId) {
        finalParams.brand_id = params.brandId;
    } else if (params.shopId) {
        Object.assign(finalParams, {
            method: 'web.shop.series',
            shop_id: params.shopId
        });
    }

    return api.get('', finalParams, config.apiCache);
};

/**
 * 获取品牌folder
 * @return
 */
const getBrandShopFolder = (params) => {
    let finalParams = {
        method: 'web.brand.folder',
        status: params.status || 1
    };

    if (params.brandId) {
        finalParams.brand_id = params.brandId;
    } else if (params.shopId) {
        Object.assign(finalParams, {
            method: 'web.shop.folder',
            shop_id: params.shopId
        });
    }

    return api.get('', finalParams, config.apiCache);
};

/**
 * 获取品牌水牌
 * @return
 */
const getNodeContent = (params) => {
    let finalParams = {
        method: 'web.html.content',
        mode: params.mode || 'release',
        node: params.node || ''
    };

    return api.get('', finalParams, config.apiCache);
};

/**
 * 一周新品上架
 * @return
 */
const getWeekNew = (params) => {

    let finalParams = {
        method: 'web.regular.recent'
    };

    Object.assign(finalParams, params);
    return api.get('', finalParams, config.apiCache);
};

const getBrandCouponAsync = (brandId, uid) => {
    let extra = {code: 200};

    if (!uid) {
        extra.cache = true;
    }

    return api.get('', {
        method: 'app.brand.getBrandIntro',
        brand_id: brandId,
        uid: uid
    }, extra);
};

/**
 * 根据关键词搜索品牌店铺信息 TODO
 * @return
 */
const getBrandShop = (query) => {
    let finalParams = {
        method: 'web.search.shopNewInfo'
    };

    return api.get('', Object.assign(finalParams, {keyword: query}), config.apiCache);
};

/**
 * 根据搜索得到店铺/品牌
 */
const getShopList = params => {
    if (!params || !params.query) {
        return;
    }

    return getBrandShop(params.query).then(shops => {
        let shopEntry = {},
            sort = _.get(shops, 'data.sortInfo.sort', {}),
            shopInfo = _.get(shops, 'data.shopBrandInfo.shopInfo', {}) ||
                _.get(shops, 'data.shopBrandInfo.brandInfo', {});

        if (_.isEmpty(shopInfo)) {
            return;
        }

        shopEntry = {
            home: helpers.urlFormat('', '', shopInfo.shop_domain || shopInfo.brand_domain),
            logo: shopInfo.shop_logo || shopInfo.brand_ico,
            shopName: shopInfo.shop_name || shopInfo.brand_name,
            sort: []
        };

        // 店铺／品牌的小分类
        _.forEach(sort, (sortInfo) => {
            _.forEach(_.get(sortInfo, 'sub', []), (subSort) => {
                shopEntry.sort.push({
                    href: helpers.urlFormat('', {misort: subSort.sort_id},
                        shopInfo.shop_domain || shopInfo.brand_domain),
                    name: subSort.sort_name
                });
            });

        });

        return shopEntry;
    });
};

/**
 * 搜索提示
 * @return
 */
const getSuggest = (params) => {
    let finalParams = {
        method: 'app.search.fuzzy',
        keyword: params.keyword || ''
    };

    return api.get('', finalParams, config.apiCache);
};


/**
 * 根据品牌域名获取品牌信息
 * @return
 */
const getBrandData = (params) => {
    let finalParams = {
        method: 'web.brand.byDomain',
        domain: params.domain || ''
    };

    return api.get('', finalParams, config.apiCache);
};

/**
 * 根据uid和品牌id判断品牌是否收藏
 * @return
 */
const isFavoriteBrand = (uid, brandId) => {
    return serviceApi.get(isFavoriteBrandUrl, {
        uid: uid,
        brandId: brandId
    });
};

/**
 * 根据shopId获取店铺基本信息
 * @return
 */
const getShopInfo = (shopId, uid) => {
    let finalParams = {
        method: 'app.shops.getIntro',
        shop_id: shopId || 0,
        uid: uid || 0
    };

    return api.get('', finalParams, config.apiCache);

};

/**
 * 查询店铺下面的所有品牌
 */
const getShopBrands = (shopId) => {
    return api.get('', {method: 'app.shops.getShopsBrands', shop_id: shopId || 0}, config.apiCache);
};

/**
 * 查询店铺装修
 */
const getShopDecorator = (shopId) => {
    return api.get('', {method: 'app.shopsdecorator.getList', shop_id: shopId || 0}, config.apiCache);
};

/**
 * 通过品牌获取相关文章
 */
const getArticleByBrand = (brand, udid, limit) => {
    let params = {
        brand_id: brand || 0,
        udid: udid,
        limit: limit || 6
    };

    return serviceApi.get(relateArticleUrl, params);
};

const getBrands4Filter = (params) => {
    return api.get('', Object.assign({
        method: 'web.regular.aggBrand'
    }, params));
};

/**
 * 有可能喜欢的商品

 * @param int $channel 频道，1代表男生，2代表女生，3代表潮童，4代表创意生活
 * @param $uid 用户ID
 * @param $udid 设备ID
 * @param $rec_pos 位置码
 * @param $limit 数量限制
 * @return array 接口返回的数据
 * */

const lessRecommend = (channel, uid, udid, recPos, limit) => {
    let param = {
        method: 'app.search.newLast7day',
        yh_channel: channel,
        udid: udid,
        rec_pos: recPos,
        limit: limit
    };

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

    return api.get('', param);
};

module.exports = {
    getSortByConditionAsync,
    getKeyActivityAsync,
    getProductList,
    getSortList,
    getSortIntro,
    getSortAds,
    getBrandShopFolder,
    getBrandShopSeries,
    getWeekNew,
    getBrandCouponAsync,
    getBrandShop,
    getSuggest,
    getBrandData,
    getNodeContent,
    isFavoriteBrand,
    getShopInfo,
    getShopBrands,
    getShopDecorator,
    getArticleByBrand,
    getShopList,
    getBrands4Filter,
    getProductListOrig,
    getSearchCacheKey,
    lessRecommend
};