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

const _ = require('lodash');

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

const ServiceAPI = require(`${global.library}/api`).ServiceAPI;
const SearchAPI = require(`${global.library}/api`).SearchAPI;
const sign = require(`${global.library}/sign`);
const helpers = require(`${global.library}/helpers`);
const images = require(`${global.utils}/images`);

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


const serviceApi = new ServiceAPI();
const searchApi = new 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;

/**
 * 获取导航信息
 * @param {[Object]} 原始数据
 * @return {[Object]} 转换后的数据
 */
const getNavs = rawNavs => {
    const navs = rawNavs;
    let list = [];

    _.forEach(navs, it => {
        let obj = {};

        obj.name = it.name;
        obj.href = it.url;

        list.push(obj);
    });

    return list;
};

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

/**
 * 格式化商品信息
 *
 * @param array $productData 需要格式化的商品数据
 * @param bool $showTags 控制是否显示标签
 * @param bool $showNew 控制是否显示NEW图标
 * @param bool $showSale 控制是否显示SALE图标
 * @param int $width 图片的宽度
 * @param int $height 图片的高度
 * @param bool $isApp 判断是不是APP访问
 * @param bool $showPoint 商品价格是否显示小数位，默认显示
 * @return array | false
 */
const formatProduct = (productData, showTags, showNew, showSale, width, height, isApp, showPoint) => {
    let result = {};

    // 默认值
    if (!showTags) {
        showTags = true;
    }
    if (!showNew) {
        showNew = true;
    }
    if (!showSale) {
        showSale = true;
    }
    if (!width) {
        width = 290;
    }
    if (!height) {
        height = 388;
    }
    if (!isApp) {
        isApp = false;
    }
    if (!showPoint) {
        showPoint = true;
    }

    // 商品信息有问题，则不显示
    if (!productData.product_skn || !productData.goods_list[0]) {
        return false;
    }

    // 市场价和售价一样，则不显示市场价
    if (parseInt(productData.market_price, 0) === parseInt(productData.sales_price, 0)) {
        productData.market_price = false;
    }

    // 设置默认图片
    _.forEach(productData.goods_list, item => {
        if (item.is_default === 'Y') {
            productData.default_images = item.images_url;
        }
    });

    if (!productData.default_images) {
        productData.default_images = productData.goods_list[0].images_url;
    }

    result.id = productData.product_skn;
    result.product_id = productData.product_id;
    result.thumb = images.getImageUrl(productData.default_images, width, height);
    result.name = productData.product_name;
    result.price = !productData.market_price ? false : productData.market_price;
    result.salePrice = productData.sales_price;
    if (showPoint) {
        result.price += '.00';
        result.salePrice += '.00';
    }

    result.is_soon_sold_out = (productData.is_soon_sold_out === 'Y');
    result.url = 'http://item.yohobuy.com/product/pro_' +
        productData.product_id + '_' +
        productData.goods_list[0].goods_id + '/' +
        productData.cn_alphabet + '.html';

    // APP访问需要加附加的参数
    // 备注：如果以后APP的接口太多，可以把这边参数提取出来，变成一个公共的方法来生成，便于以后管理维护
    if (isApp) {
        result.url += '?openby:yohobuy={"action":"go.productDetail","params":{"product_skn":' +
            productData.product_skn + '}}';
    }

    if (showTags) {
        result.tags = {};
        result.tags.is_new = showNew && productData.is_new && productData.is_new === 'Y'; // 新品
        result.tags.is_discount = showSale && productData.is_discount && productData.is_discount === 'Y'; // 在售
        result.tags.is_limited = productData.is_limited && productData.is_limited === 'Y'; // 限量
        result.tags.is_yohood = productData.is_yohood && productData.is_yohood === 'Y'; // YOHOOD
        result.tags.midYear = productData['mid-year'] && productData['mid-year'] === 'Y'; // 年中
        result.tags.yearEnd = productData['year-end'] && productData['year-end'] === 'Y'; // 年末
        result.tags.is_advance = productData.is_advance && productData.is_advance === 'Y'; // 再到着

        if (result.is_soon_sold_out && result.tags.is_discount) {
            result.tags.is_new = false;// 打折与即将售完组合显示打折
        } else if (result.tags.is_discount &&
            (result.tags.is_new || result.tags.is_limited || result.tags.is_yohood || result.tags.is_advance)) {
            result.tags.is_discount = false;// 打折与其它组合则隐藏打折
        } else if (result.tags.is_yohood && result.tags.is_new) {
            result.tags.is_new = false;// YOHOOD和新品组合显示YOHOOD
        }
    }
    return result;
};


/**
 * 获取普通banner
 * @param {[Object]} data 原始数据
 * @return {[Object]} 转换后的数据
 */
const getBannerList = data => {

    return _.map(data, item => {
        return Object.assign(item, {
            href: item.url,
            img: item.src,
            name: item.title
        });
    });
};


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

    _.mapKeys(data, (value, key) => {
        _.forEach(value, slideData => {
            let obj = {};

            obj.href = slideData.url;
            obj.img = slideData.img;

            floorData.debrisSlider[key].push(obj);
        });
    });

    return floorData;
};


/**
 * 获取广告位
 * @param {Object} data 原始数据
 * @return {Object} 转换后的数据
 */
const getadbannerData = data => {
    const obj = {
        adbanner: {
            href: '',
            img: '',
            name: ''
        }
    };

    obj.adbanner.href = data.url;
    obj.adbanner.img = data.src;
    obj.adbanner.name = data.title;

    return obj;
};

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

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

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

    if (_.isArray(srcData)) {
        slideData.slide.list = getBannerList(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 = [];
    let obj = {};

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


    let adData;
    let floorDatas = [];


    obj.href = item[0].url;
    obj.img = item[0].src;

    list.push(obj);

    _.forEach(secondItem, (floorData) => {
        let o = {};

        o.href = floorData.url;
        o.img = floorData.src;

        list.push(o);
    });

    obj.href = thirdItem[0].url;
    obj.img = thirdItem[0].src;

    list.push(obj);

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

    _.forEach(item, (topData) => {
        let o = {};

        o.href = topData.url;
        o.img = topData.src;

        data.preferenceBrands.imgBrand.push(o);
    });

    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: []
        }
    };

    _.forEach(item.data.menuNav.list, it => {
        let obj = {};


        obj.name = it.name;
        obj.href = it.url;
        category.push(obj);
    });

    _.forEach(item.data.menuNav.blocks, it => {
        let obj = {};

        obj.name = it.title;
        obj.href = it.url;
        obj.img = it.img;
        keyword.push(obj);
    });

    _.forEach(item.data.imgs, (it, idx) => {
        let obj = {};

        obj.name = it.title;
        obj.href = it.url;
        obj.img = it.img;

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

    _.forEach(nextItem.data, (it) => {
        let obj = {};

        obj.name = it.title;
        obj.href = it.url;
        obj.img = it.src;

        products.push(obj);
    });

    object.name = item.data.name;
    object.keyword = keyword;
    object.category = category;
    object.brands = brands;
    object.types = types;
    object.navs = getNavs(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 = {};
        let obj = {};

        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];
        }
        obj.href = val.url;
        obj.img = val.src;
        list.push(obj);
    }

    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 getAsyncSingleHot = (args, queryResult, type) => {
    const data = {
        singlehot: {
            name: args[0].data.text,
            navs: [],
            imgHot: [],
            brands: []
        }
    };

    if (args[3].template_name === 'app_icon_list') {
        _.forEach(args[3].data, it => {
            let obj = {};

            obj.href = it.url;
            obj.name = it.title;
            obj.img = it.src;

            data.singlehot.brands.push(obj);
        });
    }

    if (queryResult.data) {
        _.forEach(queryResult.data.product_list || [], (it, index) => {
            let obj = {};
            const formatData = formatProduct(it, true, true, true, 280, 373);

            if (index > 12) {
                return;
            }


            obj.price = formatData.salePrice;
            obj.href = formatData.url;
            obj.img = formatData.thumb;
            obj.name = formatData.name;

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

            data.singlehot.imgHot.push(obj);
        });
    }
    data.singlehot.navs = getNavs(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, floorData, queryResult, title, type) => {
    let data = {};

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

        if (text === title) {
            data = getAsyncSingleHot(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 = getNavs(args[1].data);

    return data;
};




/**
 * 获取最新上架商品数据
 *
 * @param string $channel
 * @return array
 */
exports.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(formatProduct(item, true, true, true, 280, 373));
        });

        return result;
    });
};


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

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

        obj.href = it.url;
        obj.img = it.src;

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

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

    return data;
};

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

    _.forEach(args[2].data, it => {
        let obj = {};

        obj.name = it.title;
        obj.img = it.src;
        obj.href = it.url;

        data.accordion.slide.push(obj);
    });

    return data;
};

const requestContent = type => {

    let data = sign.apiSign({
            /* eslint-disable */
            client_type: 'web',
            /* eslint-enable */
        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('获取资源位接口返回状态码 不是 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} type 传入频道页类型，值可以是: boys, girls, kids, lifestyle
 * @return {Object}
 */
exports.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,
                                result.floorData, data, result.singlehotFloorTitle[index], result.channelType));
                });

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


// 优选品牌楼层floorData-ajax
exports.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;
    });
};