/**
 * 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 images = require('../../../utils/images.js');

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.regular.groupsort'
        method: 'web.search.shopInfo'
    };

    Object.assign(finalParams, {keyword: query});

    let cKey = getSearchCacheKey(finalParams);

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

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

                    if (retObj) {
                        return retObj;
                    } else {
                        return api.get('', finalParams).then(ret => {
                            if (ret && ret.code === 200) {

                                saveCache(cKey, ret.data, CACHE_TIME_S);
                                return ret.data;
                            }
                            return null;
                        });
                    }
                });
};

/**
 * 根据品牌ID获取品牌下的店铺
 * @return
 */
const getShopsByBrandId = bid => {
    let finalParams = {
        method: 'app.shop.queryShopsByBrandId',
        brand_id: bid
    };

    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('getShopsByBrandId cache data parse fail.');
                        }
                    }

                    if (cdataObj) {
                        return cdataObj;
                    } else {
                        return api.get('', finalParams).then(ret => {
                            if (ret && ret.code === 200) {

                                saveCache(cKey, ret.data, CACHE_TIME_S);
                                return ret.data;
                            }
                            return null;
                        });
                    }
                });
};

const shopFormat = shopDatas => {
    let shopEntry = [];

    _.forEach(shopDatas, val => {
        let sorts = [];
        let shopId = _.get(val, 'shop.shop_id', '');
        let url = helpers.urlFormat('', {shopId: shopId}, val.shop.brand_domain);

        if (val.shopSort) {
            for (let ss of val.shopSort) {
                if (!ss.sub) {
                    continue;
                }

                let isFull = false;

                for (let misort of ss.sub) {
                    if (sorts.length >= 10) {
                        isFull = true;
                        break;
                    }

                    sorts.push({
                        href: `${url}&msort=${ss.sort_id}&misort=${misort.sort_id}`,
                        name: misort.sort_name
                    });
                }
                if (isFull) {
                    break;
                }
            }
        }

        shopEntry.push({
            home: url,
            logo: images.getImageUrl(val.shop.brand_ico, 80, 50, 1, 'brandLogo'),
            shopName: val.shop.brand_name,
            sort: sorts
        });
    });

    return shopEntry;
};

/**
 * 根据搜索得到店铺/品牌 列表
 */
const getShopList = params => {

    if (!params || !params.query) {
        return;
    }

    let brandShop;
    let brandShops;

    return getBrandShop(params.query).then(shop => {    // 获取品牌，并根据品牌获取品牌下的所有店铺

        if (!shop || !shop.id) {
            return;
        }

        brandShop = shop;
        return getShopsByBrandId(shop.id).then(shops => {
            if (shops && shops.length) {
                return shops;
            } else {
                return shop;
            }
        });
    }).then(shops => {  // 获取品牌/品牌店下所有的分类

        if (_.isArray(shops)) {
            brandShops = shops;

            let promises = [];

            for (let s of shops) {
                promises.push(getSortList({
                    brand: s.brand_id || brandShop.id
                }));
            }

            return Promise.all(promises);
        } else if (shops && shops.id) {
            return getSortList({
                brand: shops.id
            });
        }

    }).then(sorts => {  // 数组则为品牌店列表，否则为品牌
        let shopData = [];

        if (_.isArray(sorts)) {

            _.forEach(sorts, (val, index) => {
                shopData.push({
                    shop: brandShops[index],
                    shopSort: val && val.data && !_.isFunction(val.data.sort) && val.data.sort
                });
            });
        } else if (sorts && sorts.code === 200 && sorts.data) {
            shopData.push({
                shop: brandShop,
                shopSort: !_.isFunction(sorts.data.sort) && sorts.data.sort
            });
        }

        return shopFormat(shopData);
    });
};

/**
 * 搜索提示
 * @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));
};

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
};