/**
 * 频道页 model
 * @author: 赵彪<bill.zhao@yoho.cn>
 * @date: 2016/05/17
 */
'use strict';

const _ = require('lodash');

const dataMap = require('../../../config/data-map');

const helpers = global.yoho.helpers;

const processProduct = require(`${global.utils}/product-process`).processProduct;


const serviceApi = global.yoho.ServiceAPI;
const searchApi = global.yoho.SearchAPI;

const headerModel = require('../../../doraemon/models/header');

// 获取上线时间
const _getShelveTime = duration => {
    let today = new Date(),
        todayMil = today.getTime().toString().substr(0, 10),
        startDayMil = (today.setMonth(today.getMonth() - duration)).toString().substr(0, 10);

    return `${startDayMil},${todayMil}`; // `返回时间
};

// 获取可用的标题
const _getText = data => {
    let text = data.split(' ')[0];
    const regResult = /\w+/.exec(text);
    const titleWithoutChinese = /^(?=.*[A-Za-z0-9])[A-Za-z0-9 _]*$/;

    // 对于不含中文的标题，直接返回
    if (titleWithoutChinese.test(data)) {
        return data;
    }

    if (regResult) {

        // 去掉标题中的英文部分
        text = text.replace(regResult[0], '');
    }

    return text;
};

const channelMap = dataMap.channel;

const sortMap = dataMap.sort;

// 构建url
const _httpBuildQuery = data => {
    return searchApi.get('/search.json', data, {
        cache: true
    });
};

/**
 * 获取带小图的banner
 * @param {[Object]} data 原始数据
 * @return {[Object]} 转换后的数据
 */
const _getDebrisSlide = data => {
    let floorData = {
        debrisSlider: {
            left: [],
            center: [],
            right: []
        }
    };

    _.mapKeys(data, (value, key) => {
        _.forEach(value, slideData => {
            floorData.debrisSlider[key].push(slideData);
        });
    });

    return floorData;
};


/**
 * 获取广告位
 * @param {Object} data 原始数据
 * @return {Object} 转换后的数据
 */
const _getadbannerData = data => {

    return {
        adbanner: data
    };
};

/**
 * 生成banner模板数据
 * @param {Object} srcData 原始数据
 * @return {Object} 转换后的数据
 */
const _getSlideData = srcData => {
    const slideData = {
        slide: {
            list: [],
            pagination: []
        }
    };

    if (srcData.big_image) {
        slideData.slide.list = srcData.big_image;
    }

    if (srcData.list) {
        slideData.slide.pagination = srcData.list;
    }

    if (_.isArray(srcData)) {
        slideData.slide.list = srcData;
    }

    return slideData;
};


/**
 * 获取最新速报模板数据
 * @param {Object} srcData 原始数据
 * @return {Object} 转换后的数据
 */
const _getNewReportFloorData = args => {
    const title = args[0].data.text;
    let item = args[1].data;
    let secondItem = args[2].data;
    let thirdItem = args[3].data;
    let forthItem = args[4];

    let list = [];

    const data = {
        newReport: {
            name: title,
            list: []
        }
    };


    let adData;
    let floorDatas = [];


    list.push(item[0]);

    _.forEach(secondItem, (floorData) => {
        list.push(floorData);
    });

    list.push(thirdItem[0]);

    data.newReport.list = list;

    floorDatas.push(data);

    if (forthItem.template_name === 'single_image') {
        adData = _getadbannerData(forthItem.data[0]);
        floorDatas.push(adData);
    }

    return floorDatas;
};


/**
 * 给目标对象绑定频道属性
 * @param {Object} obj 需要绑定频道属性的对象
 * @param {String} type 需要设置的频道类型
 * @return undefined
 */
const _setChannelType = (obj, type) => {
    obj[type + 'Channel'] = true;
};

/**
 * 获取优选品牌模板数据
 * @param {[Object]} args 参数列表
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getPreBrandTopData = (args, type) => {
    const title = args[0].data.text;
    let item = args[1].data;

    const data = {
        preferenceBrands: {
            name: title,
            imgBrand: [],
            brandUrl: '/getbrandFloorDataAjax?channelType=' + type
        }
    };

    data.preferenceBrands.imgBrand = item;
    if (type === 'kids') {
        data.preferenceBrands.sliderColor = '#7AD3F8';
    }

    _setChannelType(data.preferenceBrands, type);

    return data;
};

/**
 * 获取热门分类模板数据
 * @param {[Object]} args 参数列表
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getHotGoodsFloorData = (args, type) => {
    let item = args[0];
    let nextItem = args[1];

    let list = [];

    let object = {},
        keyword = [],
        category = [],
        brands = [],
        types = [],
        products = [];

    const data = {
        recommend: {
            tplrecommend: []
        }
    };

    category = item.data.menuNav.list;

    keyword = item.data.menuNav.blocks;

    _.forEach(item.data.imgs, (it, idx) => {

        if (idx === 0 || (idx === 4 && type === 'boys')) {
            brands.push(it);
        } else {
            types.push(it);
        }
    });

    products = nextItem.data;

    object.name = item.data.name;
    object.keyword = keyword;
    object.category = category;
    object.brands = brands;
    object.types = types;
    object.navs = item.data.navs.list;
    object.products = products;
    list.push(object);

    data.recommend.tplrecommend = list;

    _setChannelType(data.recommend, type);


    return data;
};


/**
 * 获取boys人气单品模版数据
 * @param {[Object]} args 参数列表
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getBoysSingleHot = (args, type) => {
    const len = 10;
    const data = {
        singlehot: {
            name: args[0].data.text,
            imgHot: []
        }
    };

    let list = [];
    let adData;
    let floorDatas = [];

    for (let i = 0; i < len; i++) {
        let pos = i;
        let val = {};

        if (i === 1) {
            val = args[1].data[0]; // 第二个是大图
        } else if (i === len - 1) {
            val = args[1].data[1]; // 最后一个是大图
        } else {
            if (pos > 1) { // 小图
                pos = pos - 1;
            }
            val = args[2].data[pos];
        }
        list.push(val);
    }

    _.forEach(list, (item, index) => {
        if (index === 1 || index === list.length - 1) {
            item.big = true;
        }
    });

    data.singlehot.imgHot = list;
    _setChannelType(data.singlehot, type);
    floorDatas.push(data);

    if (args[3].template_name === 'single_image') {
        adData = _getadbannerData(args[3].data[0]);
        floorDatas.push(adData);
    }

    return floorDatas;
};

/**
 * 获取girls人气单品模版数据
 * @param {[Object]} args 参数列表
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getGirlsSingleHot = (args, type) => {
    let goods = args[2] && args[2].data;
    let skns = '';

    if (goods) {
        _.forEach(goods, good => {
            skns += good.id + ' ';
        });
    } else {
        return;
    }

    return searchApi.get('/search.json', {
        client_type: 'web',
        query: skns,
        order: 'shelve_time:desc',
        status: 1,
        sales: 'Y',
        attribute_not: '2',
        stocknumber: 1,
        page: 1,
        gender: channelMap[type].gender,
        viewNum: 60
    }, {
        cache: true
    });
};


/**
 * 人气单品入口
 * @param {[Object]} args 参数列表
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getSingleHotFloorData = (args, type) => {
    if (type === 'boys') {
        return _getBoysSingleHot(args, type);
    } else {
        return _getGirlsSingleHot(args, type);
    }
};

/**
 * 处理异步获取的人气单品数据
 * @param {[Object]} args 参数列表
 * @param {String} originQuery 原始skns
 * @param {Object} queryResult 异步获取的数据
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getSingehotViaResult = (args, originQuery, queryResult, type) => {
    let data = {
        singlehot: {
            name: args[0].data.text,
            navs: [],
            imgHot: [],
            brands: []
        }
    };

    let pos = 0;


    const getIndex = skn => {
        let index;


        if (originQuery) {
            const originQueryArr = originQuery.split(' ');
            let setFlag = false;

            _.forEach(originQueryArr, (query, idx) => {
                if (!setFlag && query.toString() === skn.toString()) {
                    index = idx;
                    setFlag = true;
                }
            });
        }

        return index;
    };

    if (args[3].template_name === 'app_icon_list') {
        data.singlehot.brands = args[3].data;
    }

    if (queryResult.data) {
        _.forEach(queryResult.data.product_list || [], it => {
            const formatData = processProduct(it, {
                width: 280,
                height: 373,
                gender: channelMap[type].gender
            });

            if (pos > 11) {
                return;
            }

            if (it.product_id) {
                formatData.idx = getIndex(it.product_skn);
                if (formatData.idx === 0 || formatData.idx) {
                    data.singlehot.imgHot.push(formatData);
                    pos += 1;
                }
            }
        });
    }

    data.singlehot.imgHot = _.sortBy(data.singlehot.imgHot, item => {
        return item.idx;
    });

    pos = 1;
    _.forEach(data.singlehot.imgHot, item => {
        if (pos < 4 && item) {
            item.tip = 'TOP' + pos;
            pos += 1;
        }
    });
    data.singlehot.navs = args[1].data;
    _setChannelType(data.singlehot, type);
    return data;
};

/**
 * 异步获取人气单品
 * @param {[Object]} rawData 接口返回的原始数据
 * @param {[Object]} floorData 已经经过处理的楼层数据
 * @param {String} originQuery 原始的query数据
 * @param {Object} queryResult 接口中用于请求人气单品的数据
 * @param {String} title 人气单品楼层的标题
 * @param {Type} type 人气单品楼层的类型
 * @return {Object}
 */
const _processFloorDataWithQueryReusult = (rawData, originQuery, queryResult, title, type) => {
    let data = {};

    _.forEach(rawData, (subData, index) => {
        const text = subData.data.text && _getText(subData.data.text);


        if (text === title) {
            data = _getSingehotViaResult(rawData.slice(index, index + 4), originQuery, queryResult, type);
        }
    });

    return data;
};

/**
 * 组装最新上架楼层数据
 *
 * @param string data
 * return obj
 */
const _getNewGoodsFloorData = args => {
    const data = {
        newArrivls: {
            name: args[0].data.text,
            navs: []
        }
    };

    data.newArrivls.navs = args[1].data;

    return data;
};

const _getCategoryFloorData = args => {
    const data = {
        category: {
            name: args[0].data.text,
            navs: args[1].data,
            list: []
        }
    };

    _.forEach(args[2].data, (it, index) => {

        // 设置图片大小
        if (index === 1) {
            it.w = '377;';
            it.h = '504;';
        } else {
            it.w = '185';
            it.h = '510';
        }

        data.category.list.push(it);
    });

    return data;
};

const _getAccordionFloorData = args => {
    let data = {
        accordion: {
            name: args[0].data.text,
            navs: args[1].data,
            slide: []
        }
    };

    data.accordion.slide = args[2].data;

    return data;
};

const _requestContent = type => {
    let data = {
        client_type: 'web',
        content_code: channelMap[type || 'boys'].code,
        gender: channelMap[type || 'boys'].gender,
        page: 1,
        limit: 1000
    };

    return serviceApi.get('operations/api/v5/resource/home', data, {
        cache: true,
        code: 200
    }).then(result => {
        return result;
    });
};

const floorMap = {
    slide: _getSlideData,
    hot: _getHotGoodsFloorData,
    最新速报: _getNewReportFloorData,
    人气单品: _getSingleHotFloorData,
    'GIRL KIDS': _getSingleHotFloorData,
    'BOY KIDS': _getSingleHotFloorData,
    ACCESSORIES: _getSingleHotFloorData,
    优选品牌: _getPreBrandTopData,
    最新上架: _getNewGoodsFloorData,
    ad: _getadbannerData,
    category: _getCategoryFloorData,
    accordion: _getAccordionFloorData,
    debrisSlide: _getDebrisSlide
};


const needQuery = {
    'GIRL KIDS': true,
    'BOY KIDS': true,
    人气单品: true,
    ACCESSORIES: true
};

const getQuery = args => {
    let goods = args[2] && args[2].data;
    let skns = '';

    if (goods) {
        _.forEach(goods, good => {
            skns += good.id + ' ';
        });
    }

    return skns;
};


const _processFloorData = (rawData, type) => {
    let floorList = [];
    let searchPromise = [];
    let singlehotFloorIndex = [];
    let singlehotFloorTitle = [];
    let params = [];

    // 定义各种楼层需要用到的接口返回的数组中元素的个数
    const bigFloorLength = 5;
    const normalFloorLength = 3;
    const hotCategoryLength = 2;


    _.forEach(rawData, (data, index) => {
        let floorData = null;
        let queryParam = '';

        if (data.template_name === 'recommend_content_three' ||
           (data.template_intro === '焦点图' && index === 0)) { // 处理banner
            floorData = floorMap.slide.call(null, data.data);
        } else if (data.template_intro === '热门品类') { // 处理热门品类
            floorData = floorMap.hot.call(null, rawData.slice(index, index + hotCategoryLength), type);
        } else if (data.data && data.data.text) { // 处理一般楼层
            let text = _getText(data.data.text);
            let lastIndex = index + bigFloorLength < rawData.length ?
                            index + bigFloorLength : index + (rawData.length - index - 1);


            floorData = floorMap[text] &&
                        floorMap[text].call(null, rawData.slice(index, lastIndex), type);

            if (needQuery[text]) {
                queryParam = getQuery(rawData.slice(index, lastIndex));
                if (queryParam.length > 0) {
                    params.push(queryParam);
                }
            }

        } else if (data.template_name === 'debrisSlider') { // 处理girls的banner
            floorData = floorMap.debrisSlide.call(null, data.data);
        }

        // 处理lifestyle分类楼层
        if (!floorData && index + normalFloorLength < rawData.length &&
            rawData[index + 1].template_name === 'textNav' &&
            rawData[index + 2].template_name === 'floor') {
            floorData = floorMap.category.call(null, rawData.slice(index, index + normalFloorLength));
        }

        // 处理手风琴楼层
        if (!floorData && index + normalFloorLength < rawData.length &&
            rawData[index + 1].template_name === 'textNav' &&
            rawData[index + 2].template_name === 'focus') {
            floorData = floorMap.accordion.call(null, rawData.slice(index, index + normalFloorLength));
        }


        // 处理promise
        if (floorData && floorData.then && typeof floorData.then === 'function') {
            searchPromise.push(floorData);

            // 记住楼层位置, 以便后面promise获取数据后插入楼层数据
            singlehotFloorIndex.push(floorList.length);

            // 记住楼层标题, 以便后面promise获取数据后插入楼层数据
            singlehotFloorTitle.push(_getText(data.data.text));
        } else if (!_.isNil(floorData)) {
            _.isArray(floorData) ?
                floorList = floorList.concat(floorData) :
                floorList.push(floorData);
        }
    });

    return {
        floors: floorList,
        promise: _.reverse(searchPromise),
        queryParams: _.reverse(params),
        singlehotFloorTitle: _.reverse(singlehotFloorTitle),
        singlehotFloorIndex: _.reverse(singlehotFloorIndex)
    };
};

const _formatResourceParams = (channel, code) => {
    return serviceApi.get('operations/api/v5/resource/get', {content_code: code}, {
        cache: true
    }).then(data => {
        let result = data && data.data[0] && data.data[0].data[0];

        if (result) {
            result.channel = channel;
        }

        return result || {};
    });
};

/**
 * 频道页首次登陆导航并行调接口数据
 * @param  {Object} data
 * @return {Object} formatData
 */
const _formatParams = (channel, data) => {
    let params = {};

    // 排序数据映射表
    let orderMaps = {
        s_t_desc: 'shelve_time:desc',
        s_t_asc: 'shelve_time:asc',
        s_p_asc: 'sales_price:asc',
        s_p_desc: 'sales_price:desc',
        p_d_desc: 'discount:desc',
        p_d_asc: 'discount:asc',
        skn_desc: 'product_skn:desc',
        skn_asc: 'product_skn:asc',
        activities_desc: 'activities.order_by:desc',
        activities_asc: 'activities.order_by:asc',
        s_n_asc: 'sales_num:asc',
        s_n_desc: 'sales_num:desc',
        activities_id_desc: 'activities.activity_id:desc',
        activities_id_asc: 'activities.activity_id:asc',
        brand_desc: 'brand_weight:desc'
    };

    params.status = 1; // 是否上架，1表示在架，2表示不在
    params.sales = 'Y'; // 只搜索销售的产品
    params.outlets = 2; // 非奥莱商品
    params.stocknumber = 1; // 过滤掉已售罄的商品
    params.attribute_not = 2; // 过滤掉赠品
    if (!data.order) {
        params.order = orderMaps.s_t_desc;
    } else {
        params.order = orderMaps[data.order] ? orderMaps[data.order] : '';
    }
    if (!data.page) {
        params.page = 1;
    }

    if (data.viewNum) {
        params.viewNum = data.viewNum;
    } else if (!data.limit) {
        params.viewNum = 60;
    } else {
        params.viewNum = data.limit;
        delete data.limit;
    }
    if (data) {
        params = Object.assign(data);
    }
    return searchApi.get('/search.json', params).then(result => {
        let ret = result.data;

        ret.channel = channel;

        return ret;
    });
};

/**
 * 格式化频道页首次登陆导航数据
 * @param  {Object} data
 * @return {Object} formatData
 */
const formatIndexGuideData = data => {
    let channels = {
        boys: {gender: '1,3', limit: 1},
        girls: {gender: '2,3', limit: 1},
        lifestyle: {msort: 10, misort: '266,280,101,103,259', limit: 1},
        kids: {msort: 365, limit: 1}
    };
    let formatData = [];
    let promiseArr = [];

    _.forEach(data, item => {
        let channel = item.sort_name_en.toLowerCase().replace(' ', '');

        formatData.push({
            channel: channel,
            url: item.sort_url,
            sort_name: item.sort_name,
            sort_name_en: item.sort_name_en,
            content_code: item.content_code,
            src: '',
            num: 0
        });

        if (channels[channel]) {
            promiseArr.push(_formatParams(channel, channels[channel]));
        }
    });

    return Promise.all(promiseArr).then(result => {
        _.forEach(formatData, (item, index) => {
            _.forEach(result, (it, idx) => {
                if (formatData[index].channel === result[idx].channel) {
                    formatData[index].num = result[idx].total;
                }
            });
        });

        return formatData;
    });
};

/**
 * 获取最新上架商品数据
 *
 * @param string $channel
 * @return array
 */
const getNewArrival = channel => {
    let rel = [],
        sortList = sortMap[channel],
        params = {
            order: 'shelve_time:desc',
            status: 1,
            sales: 'Y',
            attribute_not: 2,
            stocknumber: 3,
            shelve_time: _getShelveTime(2)
        };

    params.gender = channelMap[channel].gender;


    _.forEach(sortList, (item) => {
        let data = Object.assign(item, params);

        rel.push(_httpBuildQuery(data));
    });

    return Promise.all(rel).then(res => {
        let data = [],
            result = [];

        _.forEach(sortList, (it, index) => {
            if (res[index].data &&
                res[index].data.product_list.length === sortList[index].viewNum) {

                data = data.concat(res[index].data.product_list);
            }
        });

        _.forEach(data, (item) => {
            result.push(processProduct(item, {
                width: 280,
                height: 373,
                gender: params.gender
            }));
        });

        return result;
    });
};




/**
 * 获取频道页数据
 * @param  {String} type 传入频道页类型，值可以是: boys, girls, kids, lifestyle
 * @return {Object}
 */
const getContent = type => {
    return Promise.all([headerModel.requestHeaderData(type), _requestContent(type)]).then(res => {

        let headerData = res[0].data || res[0],
            contentData = res[1].data ? res[1].data.list : res[1];

        let data = {};

        const processResult = _processFloorData(contentData, type);

        data = headerData;
        data.module = 'channel';
        data.page = 'channel';
        data.pageType = type;
        data.footerTop = true;
        data.channel = processResult.floors;


        return {
            rawData: contentData,
            floorData: data,
            searchPromise: processResult.promise,
            singlehotFloorIndex: processResult.singlehotFloorIndex,
            singlehotFloorTitle: processResult.singlehotFloorTitle,
            queryParams: processResult.queryParams,
            channelType: type
        };

    }).then(result => {

        // 如果有promise则做相应处理
        if (result.searchPromise.length) {
            return Promise.all(result.searchPromise).then(res => {
                _.forEach(res, (data, index) => {
                    result.floorData.channel
                        .splice(result.singlehotFloorIndex[index], 0,
                            _processFloorDataWithQueryReusult(
                                result.rawData,
                                result.queryParams[index],
                                data,
                                result.singlehotFloorTitle[index],
                                result.channelType
                            ));
                });

                return result.floorData;
            });
        } else {
            return result.floorData || result;
        }
    });
};


// 优选品牌楼层floorData-ajax
const getbrandFloorDataAjax = type => {
    return _requestContent(type).then(res => {
        let contentData = res.data ? res.data.list : [];

        let data = {
            logoBrand: [],
            moreBrand: ''
        };

        _.forEach(contentData, (d, index) => {
            if (d.data && d.data.text && d.data.text.indexOf('优选品牌') >= 0) {
                _.forEach(contentData[index + 2].data, (floorData) => {
                    let o = {};

                    o.href = floorData.url;
                    o.img = helpers.image(floorData.src, 185, 86, 2);

                    data.logoBrand.push(o);
                });

                data.moreBrand = contentData[index + 3].data[0].url;
            }
        });

        return data;
    });
};

const getResourceData = (formatData) => {
    let promiseArr = [];

    _.forEach(formatData, item => {
        if (item.content_code) {
            promiseArr.push(_formatResourceParams(item.channel, item.content_code));
        }
    });
    return Promise.all(promiseArr).then(data => {
        _.forEach(formatData, (item, index) => {
            _.forEach(data, (it, idx) => {
                if (formatData[index].channel === data[idx].channel) {
                    formatData[index].src = data[idx].src;
                }
            });
        });

        return formatData;
    });
};

/**
 * 获取频道页首次登陆导航数据
 * @param  {String} type 传入频道页类型，值可以是: boys, girls, kids, lifestyle
 * @return {Object}
 */
const getIndexGuideData = () => {
    let params = {
        client_type: 'web',
        private_key: '0ed29744ed318fd28d2c07985d3ba633'
    };

    return serviceApi.get('operations/api/v6/category/getCategory', params, {
        cache: true
    });
};

module.exports = {
    getNewArrival: getNewArrival,
    getContent: getContent,
    getbrandFloorDataAjax: getbrandFloorDataAjax,
    getIndexGuideData: getIndexGuideData,
    formatIndexGuideData: formatIndexGuideData,
    getResourceData: getResourceData

};