/**
 * Created by TaoHuang on 2016/6/14.
 */
'use strict';
const _ = require('lodash');
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 getSearchCackeKey = params => {
    let ks = [];

    _.forEach(params, (val, key) => {
        if (params.hasOwnProperty(key) && !_.includes(['page', 'limit', 'need_filter', 'order'], key)) {
            ks.push(val);
        }
    });

    return 'search_custom_' + md5(ks.join('_'));
};

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,
        order: 's_n_desc',
        need_filter: 'yes',
        limit: 60
    };

    Object.assign(finalParams, params);

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

    if (!config.useCache) {
        return getProductListOrig(finalParams);
    } else {
        let cKey = getSearchCackeKey(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
                        }), 3600);
                    }
                }

                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 = getSearchCackeKey(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, 3600);
                    }
                    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 getBrandSeries = (params) => {

    let finalParams = {
        method: 'web.brand.series',
        brand_id: params.brandId,
        status: params.status || 1
    };

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

/**
 * 获取品牌folder
 * @return
 */
const getBrandFolder = (params) => {

    let finalParams = {
        method: 'web.brand.folder',
        brand_id: params.brandId,
        status: params.status || 1
    };

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

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

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

    let cKey = getSearchCackeKey(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, 3600);
                    return ret.data;
                }
                return null;
            });
        }
    });
};

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

    let cKey = getSearchCackeKey(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, 3600);
                    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
                }));
            }

            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
    }, config.apiCache);
};

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

    return api.get('', finalParams);

};

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

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

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

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

const getBrands4Filter = (params) => {

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

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

module.exports = {
    getSortByConditionAsync,
    getKeyActivityAsync,
    getProductList,
    getSortList,
    getSortIntro,
    getSortAds,
    getBrandFolder,
    getBrandSeries,
    getWeekNew,
    getBrandShop,
    getSuggest,
    getBrandData,
    getNodeContent,
    isFavoriteBrand,
    getShopInfo,
    getShopBrands,
    getShopDecorator,
    getArticleByBrand,
    getShopList,
    getBrands4Filter,
    getProductListOrig,
    getSearchCackeKey
};