/**
 * search model
 * @author: wsl<shuiling.wang@yoho.cn>
 * @date: 2016/07/21
 */
'use strict';
const utils = '../../../utils';
const logger = global.yoho.logger;
const camelCase = global.yoho.camelCase;
const productProcess = require(`${utils}/product-process`);
const _ = require('lodash');
const helpers = global.yoho.helpers;
const api = global.yoho.API;

/**
 * 排序转换
 */
const typeCont = {
    price: ['s_p_desc', 's_p_asc'],
    discount: ['p_d_desc', 'p_d_asc'],
    sale: ['s_n_desc', 's_n_asc'],
    newest: ['s_t_desc', 's_t_asc'],
    stock: ['s_s_desc', 's_s_asc'],
    all: ['d_s_desc', 'd_s_asc'],
    category: ['s_t_desc', 's_t_asc']
};

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

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

    // params.yh_channel = channelType[params.yh_channel];

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

    if (typeCont[params.type]) {
        params.order = typeCont[params.type][params.order];
    }

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

/**
 * 品牌名称处理
 * @param  {[object]} list
 * @return {[object]}
 */
const _processBrandNames = (list) => {
    const formatData = [];

    list = list || [];
    list = camelCase(list);

    _.forEach(list, (item) => {
        _.forEach(item, (obj) => {
            formatData.push({
                brandDomain: obj.brandDomain,
                brandName: obj.brandName
            });
        });
    });

    return formatData;
};

/**
 * 品牌名称处理
 * @param  {[object]} list
 * @return {[object]}
 */
const _processClassNames = (list) => {
    const formatData = {
        first: {},
        second: {}
    };

    list = list || [];
    list = camelCase(list);

    _.forEach(list, (item) => {
        _.forEach(item, (obj) => {
            formatData.first[obj.categoryId] = obj.categoryName;

            if (obj.sub) {
                _.forEach(obj.sub, (sub) => {
                    formatData.second[sub.categoryId] = sub.categoryName;
                });
            }

        });
    });

    return formatData;
};

/* 多品牌店铺列表数据信息处理*/
const _processBrandShops = (list) => {
    const formatDat = [];

    list = list || [];
    list = camelCase(list);

    _.forEach(list, (item) => {
        if (item.shopId) {
            formatDat.push({
                url: helpers.urlFormat('/product/index/brand/', {
                shop_id: item.brandId
            }),
            thumb: helpers.image(item.brandIco, 75, 40),
            name: item.brandName
            });
        }
    });

    return formatDat;
};

/**
 * 获取品牌信息数据
 * @param  {int} brandId 品牌ID
 * @return array         banner数据
 */
const getBrandIntro = (brandId, uid) => {
    let param = {};

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

    return api.get('', _.assign({
        method: 'app.brand.getBrandIntro',
        brand_id: brandId
    }, param), {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            let list = camelCase(result.data) || {};

            return {
                id: list.brandId,
                intro: list.brandIntro,
                collected: (list.isFavorite && list.isFavorite === 'Y') ? true : false,
                title: list.brandName ? list.brandName : ''
            };
        } else {
            logger.error('获取店铺信息接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 获取品牌banner数据
 * @param  {int} brandId 品牌ID
 * @return array         banner数据
 */
const getBrandBanner = (brandId) => {
    return api.get('', {
        method: 'app.brand.banner',
        brand_id: brandId
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            if (result.data.banner) {
                return helpers.image(result.data.banner, 640, 150);
            } else {
                return '';
            }
        } else {
            logger.error('获取店铺banner接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 获取商品数据
 */
const getSearchData = (params) => {
    return _searchSales(params).then((result) => {
        if (result && result.code === 200) {
            return productProcess.processProductList(result.data.product_list || []);
        } else {
            logger.error('商品搜索返回 code 不是 200');
            return [];
        }
    });
};

/**
 * 获取筛选数据
 * @param  {[object]} params
 * @return {[array]}
 */
const getFilterData = (params) => {
    return _searchSales(params).then((result) => {
        if (result && result.code === 200) {
            return productProcess.processFilter(result.data.filter || []);
        } else {
            logger.error('商品搜索返回 code 不是 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('品牌名称接口返回 code 不是 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('品类名称接口返回 code 不是 200');
            return {};
        }
    });
};

/**
 * 根据品牌域名获取品牌LOGO
 * @param {string} domain 品牌域名
 * @return array | false
 */
const getBrandLogoByDomain = (domain) => {
    return api.get('', {
        method: 'web.brand.byDomain',
        domain: domain
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            if (result.data) {
                let formatData = camelCase(result.data);

                return {
                    id: formatData.id,
                    url: helpers.urlFormat('', null, formatData.brandDomain),
                    thumb: helpers.image(formatData.brandIco, 75, 40),
                    name: formatData.brandName,
                    shopId: formatData.shopId ? formatData.shopId : 0,//店铺id
                    type: formatData.type ? formatData.type : 0
                }
            } else {
                return false;
            }
        } else {
            logger.error('获取品牌logo接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 根据brandId 获取相关店铺列表
 * @param brandId
 * @return array
 */
const getBrandShops = (brandId) => {
    return api.get('', {
        method: 'app.shop.queryShopsByBrandId',
        brand_id: brandId
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            return _processBrandShops(result.data);
        } else {
            logger.error('根据brandId获取店铺列表接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 收藏
 * @param {int} id 品牌ID
 * @param {int} uid 用户ID
 * @param {bool} isBrand 是品牌还是商品
 * @return array
 */
const setFavorite = (id, uid, isBrand) => {
    isBrand = isBrand || true;

    return api.post('', {
        method: 'app.favorite.add',
        id: id,
        uid: uid,
        type: isBrand ? 'brand' : 'product'
    });
};

/**
 * 取消收藏
 *
 * @param {int} id 品牌ID
 * @param {int} uid 用户ID
 * @param {bool} isBrand 是品牌还是商品
 * @return array
 */
const setFavoriteCancel = (id, uid, isBrand) => {
    isBrand = isBrand || true;

    return api.post('', {
        method: 'app.favorite.cancel',
        fav_id: id,
        uid: uid,
        type: isBrand ? 'brand' : 'product'
    });
};

/**
 * 获取店铺装修的所有资源接口
 * @param {int} shopId 店铺id
 * @return array
 */
const getShopDecorator = (shopId) => {
    return api.get('', {
        method: 'app.shopsdecorator.getList',
        shop_id: shopId
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            return camelCase(result);
        } else {
            logger.error('获取店铺装修的所有资源接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 获取店铺信息
 * @param {int} shopId 店铺id
 * @param {int} uid 用户id 判断用户是否收藏店铺
 * @return array
 */
const getShopInfo = (shopId, uid) => {
    return api.get('', {
        method: 'app.shops.getIntro',
        shop_id: shopId,
        uid: uid || 0
    }).then((result) => {
        if (result && result.code === 200) {
            return camelCase(result);
        } else {
            logger.error('获取店铺信息接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 获取店铺下面的所有分类
 * @param {int} shopId 店铺id
 * @return array
 */
const getShopCategory = (shopId, channel) => {
    return api.get('', {
        method: 'app.shop.getSortInfo',
        yh_channel: channel,
        shop_id: shopId
    }).then((result) => {
        if (result && result.code === 200) {
            return camelCase(result);
        } else {
            logger.error('获取店铺下面的所有分类接口返回code 不是 200');
            return {};
        }
    });
};

/**
 * 组织店铺页面数据
 * @param {array} data 接口返回的店铺页所需数据
 * @param {int} shopId 店铺id
 * @param {int} isAap app版本
 * @return array
 */
const formShopData = (data, shopId, isApp) => {

};

module.exports = {
    getSearchData,
    getFilterData,
    getAllBrandNames,
    getClassNames,
    getBrandLogoByDomain,
    getBrandIntro,
    getBrandShops,
    getBrandBanner,
    setFavorite,
    setFavoriteCancel,
    getShopDecorator,
    getShopInfo,
    getShopCategory,
    formShopData
};