/**
 * 频道页 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 log = global.yoho.logger;

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

    if (data === 'GIRL KIDS' || data === 'BOY KIDS') {
        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);
};

/**
 * 获取带小图的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;

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

    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 => {
    let goods = args[2].data;
    let skns = '';


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

    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,
        viewNum: 60
    });
};


/**
 * 人气单品入口
 * @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 {Object} queryResult 异步获取的数据
 * @param {String} type 频道类型
 * @return {Object}
 */
const _getSingehotViaResult = (args, queryResult, type) => {
    const data = {
        singlehot: {
            name: args[0].data.text,
            navs: [],
            imgHot: [],
            brands: []
        }
    };

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

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

            if (index > 12) {
                return;
            }

            if (index < 3) {
                formatData.tip = 'TOP' + (index + 1);
            }

            data.singlehot.imgHot.push(formatData);
        });
    }
    data.singlehot.navs = args[1].data;
    _setChannelType(data.singlehot, type);
    return data;
};

/**
 * 异步获取人气单品
 * @param {[Object]} rawData 接口返回的原始数据
 * @param {[Object]} floorData 已经经过处理的楼层数据
 * @param {Object} queryResult 接口中用于请求人气单品的数据
 * @param {String} title 人气单品楼层的标题
 * @param {Type} type 人气单品楼层的类型
 * @return {Object}
 */
const _processFloorDataWithQueryReusult = (rawData, 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), 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).then(res => {
        if (res.code === 200) {
            return res;
        } else {
            log.error('response code of "operations/api/v5/resource/home"  200');
            return {};
        }
    });
};

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



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

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


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

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

        } 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),
        singlehotFloorTitle: _.reverse(singlehotFloorTitle),
        singlehotFloorIndex: _.reverse(singlehotFloorIndex)
    };
};

/**
 * 获取最新上架商品数据
 *
 * @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(20)
        };

    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.product_list && 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
            }));
        });

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

module.exports = {
    getNewArrival: getNewArrival,
    getContent: getContent,
    getbrandFloorDataAjax: getbrandFloorDataAjax
};