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

const config = global.yoho.config;

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

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

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

const GLOBAL_BASE_URI = '/product/global/list';

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

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

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

function getProductListOrig(finalParams) {
    return this.get({data: finalParams});
}

function getKeyActivityAsync(query) {
    return this.get({
        data: {
            method: 'app.search.word',
            query: query
        }, param: {
            catch: true,
            code: 200
        }
    });
}

/**
 * 获取商品列表
 * @return
 */
function 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 this.getProductListOrig(finalParams);
    } else {
        let cKey = this.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 this.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;
                });
            });
    }
}

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

    Object.assign(finalParams, params);

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

    return this.getProductListOrig(finalParams);
}

function getSortListOrig(finalParams) {
    return this.get({data: finalParams, param: config.apiCache});
}

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

    Object.assign(finalParams, params);

    if (channel) {
        switch (channel) {
            case 'boys':
                finalParams.yh_channel = 1;
                break;
            case 'girls':
                finalParams.yh_channel = 2;
                break;
            case 'kids':
                finalParams.yh_channel = 3;
                break;
            case 'lifestyle':
                finalParams.yh_channel = 4;
                break;
            default:
                break;
        }
    }

    if (!config.useCache) {
        return this.getSortListOrig(finalParams);
    } else {
        let cKey = this.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 this.getSortListOrig(finalParams).then(ret => {
                        if (ret && ret.code === 200) {
                            _saveCache(cKey, ret, CACHE_TIME_S);
                        }
                        return ret;
                    });
                }
            });
    }
}

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

    Object.assign(finalParams, params);
    return this.get({data: finalParams, param: config.apiCache});
}

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

    Object.assign(finalParams, params);
    return this.get({data: finalParams, param: config.apiCache});
}

/**
 * 获取品牌系列
 * @return
 */
function 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 this.get({data: finalParams, param: config.apiCache});
}

/**
 * 获取品牌folder
 * @return
 */
function 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 this.get({data: finalParams, param: config.apiCache});
}

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

    return this.get({data: finalParams, param: config.apiCache});
}

/**
 * 一周新品上架
 * @return
 */
function getWeekNew(params) {

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

    Object.assign(finalParams, params);
    return this.get({data: finalParams, param: {cache: config.apiCache}});
}

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

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

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

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

    return this.get({data: Object.assign(finalParams, {keyword: query}), param: config.apiCache});
}

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

    return this.getBrandShop(params.query).then(shops => {
        let shopEntry = [];

        _.forEach(_.get(shops, 'data.shopList', []), value => {
            let shopInfo = {
                home: helpers.urlFormat('', null, value.shop_domain || value.brand_domain),
                logo: value.shop_logo || value.brand_ico,
                shopName: value.shop_name || value.brand_name,
                shopType: '',
                sort: []
            };

            if (value.is_global === 'Y') {
                shopInfo.home = helpers.urlFormat(GLOBAL_BASE_URI, {brand: value.global_brand_id});
                shopInfo.shopType = 'global-brand';
            }

            // 店铺／品牌的小分类
            _.forEach(_.get(value, 'sortInfo.sort', []), sortInfo => {
                _.forEach(_.get(sortInfo, 'sub', []), subSort => {
                    let sortHref;

                    if (value.is_global !== 'Y') {
                        sortHref = helpers.urlFormat('', {misort: subSort.sort_id},
                            value.shop_domain || value.brand_domain);
                    } else {
                        sortHref = helpers.urlFormat(GLOBAL_BASE_URI, {
                            misort: subSort.sort_id,
                            brand: value.global_brand_id
                        });
                    }
                    shopInfo.sort.push({
                        href: sortHref,
                        name: subSort.sort_name
                    });
                });
            });

            shopEntry.push(shopInfo);
        });

        return shopEntry;
    });
}

/**
 * 搜索提示
 * @return
 */
function getSuggest(params) {

    let finalParams = {
        method: 'app.search.fuzzy',
        keyword: params.keyword || ''
    };

    return this.get({data: finalParams, param: config.apiCache});
}


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

    return this.get({data: finalParams, param: config.apiCache});
}

/**
 * 根据uid和品牌id判断品牌是否收藏
 * @return
 */
function isFavoriteBrand(uid, brandId) {
    return this.get({
        url: isFavoriteBrandUrl,
        data: {
            uid: uid,
            brandId: brandId
        },
        api: global.yoho.ServiceAPI
    });
}

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

    return this.get({data: finalParams, param: config.apiCache});

}

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

/**
 * 查询店铺装修
 */
function getShopDecorator(shopId) {
    return this.get({
        data: {method: 'app.shopsdecorator.getList', shop_id: shopId || 0},
        param: config.apiCache
    });
}

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

    return this.get({
        url: relateArticleUrl,
        data: params,
        param: config.apiCache,
        api: global.yoho.ServiceAPI
    });
}

function getBrands4Filter(params) {
    return this.get({
        data: 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 接口返回的数据
 * */

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

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

    return this.get({data: param, param: config.apiCache});
}

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

        this.getKeyActivityAsync = getKeyActivityAsync.bind(this);
        this.getProductList = getProductList.bind(this);
        this.getSeoProductList = getSeoProductList.bind(this);
        this.getSortList = getSortList.bind(this);
        this.getSortIntro = getSortIntro.bind(this);
        this.getSortAds = getSortAds.bind(this);
        this.getBrandShopFolder = getBrandShopFolder.bind(this);
        this.getBrandShopSeries = getBrandShopSeries.bind(this);
        this.getWeekNew = getWeekNew.bind(this);
        this.getBrandCouponAsync = getBrandCouponAsync.bind(this);
        this.getBrandShop = getBrandShop.bind(this);
        this.getSuggest = getSuggest.bind(this);
        this.getBrandData = getBrandData.bind(this);
        this.getNodeContent = getNodeContent.bind(this);
        this.isFavoriteBrand = isFavoriteBrand.bind(this);
        this.getShopInfo = getShopInfo.bind(this);
        this.getShopBrands = getShopBrands.bind(this);
        this.getShopDecorator = getShopDecorator.bind(this);
        this.getArticleByBrand = getArticleByBrand.bind(this);
        this.getShopList = getShopList.bind(this);
        this.getBrands4Filter = getBrands4Filter.bind(this);
        this.getProductListOrig = getProductListOrig.bind(this);
        this.getSearchCacheKey = getSearchCacheKey.bind(this);
        this.lessRecommend = lessRecommend.bind(this);
        this.getSortListOrig = getSortListOrig.bind(this);
    }
};