/*
 * @Author: Targaryen
 * @Date:   2016-05-25 18:16:59
 * @Last Modified by:   Targaryen
 * @Last Modified time: 2016-06-17 20:31:42
 */

'use strict';
const library = '../../../library';
const helpers = require(`${library}/helpers`);
const _ = require('lodash');
const anHour = 3600000;
const aDay = anHour * 24;
const timeFormat = {
    d: '剩{d}天',
    h: '剩{h}小时',
    m: '剩{m}分钟',
    s: '剩{s}秒',
    dh: '剩{d}天{h}小时',
    dhms: '剩{d}天{h}小时{m}分钟{s}秒',
    hms: '剩{h}小时{m}分钟{s}秒',
    ms: '剩{m}分钟{s}秒'
};

/**
 * 折扣专场专题列表过期时间处理
 * @param time 接口返回的时间
 * @returns {*|string}
 */
const processTime = (time) => {
    let data = {};
    let type = '';

    if (time < anHour) {
        data.warnColor = true;
        data.time = '即将结束';
    } else {
        if (time > aDay) {
            type = 'dh';
        } else {
            type = 'h';
        }

        data.time = helpers.dateDiffFormat(timeFormat[type], time, 'ms');
    }

    return data.time;
};

/**
 * 折扣文本切割
 * @param text 要切割的文本
 * @returns {{discount: *, discountText: *}}
 */
const discountSplit = (text) => {
    let endNum = 0,
        i;

    for (i = 0; i < text.length; i++) {
        if (/^([0-9]|\%)*$/.test(text[i])) {
            endNum = i + 1;
        }
    }

    return {
        discount: text.slice(0, endNum),
        discountText: text.slice(endNum, text.length)
    };
};

/**
 * 处理用于筛选的 URL ， 拼接 URL 参数
 * @param originParam 当前 URL 中的参数
 * @param newParam 要拼接的 参数
 * @returns {string}
 */
const handleFilterUrl = (originParam, newParam) => {
    let dest = '?';
    let tempOriginParam = {};

    tempOriginParam = Object.assign(tempOriginParam, originParam, newParam);

    _.forEach(tempOriginParam, function(value, key) {
        dest = dest + key + '=' + value + '&';
    });

    return _.trim(dest, '&');
};

/**
 * 处理最新降价折扣信息
 * @param params 当前 URL 的参数
 * @returns {Array|*[]}
 */
const handleSaleNewSaleSortData = (params) => {
    var dest;

    dest = [{
        name: '1~3折',
        href: handleFilterUrl(params, {p_d: '0.1,0.3'}),
        checked: (params.p_d === '0.1,0.3') ? true : false
    }, {
        name: '4~6折',
        href: handleFilterUrl(params, {p_d: '0.4,0.6'}),
        checked: (params.p_d === '0.4,0.6') ? true : false
    }, {
        name: '7折以上',
        href: handleFilterUrl(params, {p_d: '0.7,1'}),
        checked: (params.p_d === '0.7,1') ? true : false
    }];

    return dest;
};

/**
 * 处理选中数据
 * @param params 当前 URL 中已有的参数
 * @param origin 要处理的数据
 * @param param 此组数据的键名
 * @returns {Array}
 */
const handleCheckedData = (params, origin, param) => {
    var dest = [];

    if (!_.isEmpty(origin)) {
        _.forEach(origin, (value) => {
            if (value.checked) {
                let checked = {};

                checked.name = value.name;

                let tempParam = {};

                tempParam[param] = '';
                checked.href = handleFilterUrl(params, tempParam);

                dest.push(checked);
            }
        });
    }

    return dest;
};

/**
 * 处理品牌筛选数据 待处理
 * @param params
 * @param origin
 * @returns {{}}
 */
const handleBrandCheckedData = (params, origin) => {
    let dest = [];

    // 分拆品牌参数
    let brands = _.split(params.brand, ',');
    let intBrands = [];

    _.forEach(brands, value => {
        intBrands.push(parseInt(value, 10));
    });

    // 遍历品牌数据，如果在参数中，那么加 checked，将此数据加入到 checked 数组中
    if (!_.isEmpty(origin)) {
        _.forEach(origin, (value) => {
            if (typeof _.find(intBrands, o => {
                return _.isEqual(o, value.id);
            }) !== 'undefined') {

                let checked = {}; // push 到已选择数组

                checked.name = value.name;

                // 为了不污染原始数据
                let tempIntBrands = _.cloneDeep(intBrands);

                // 去掉当前选项
                _.remove(tempIntBrands, n => {
                    return n === value.id;
                });

                // 拼接参数
                let brand = '';

                _.forEach(tempIntBrands, subValue => {
                    brand += subValue + ',';
                });

                // 清除参数，保留没有去掉的参数
                let tempParam = {
                    brand: brand
                };

                checked.href = handleFilterUrl(params, tempParam);

                dest.push(checked);
            }
        });
    }
    return dest;
};

/**
 * 处理断码区尺码筛选数据
 * @param origin 尺码原始数据
 * @param params 当前 URL 中已有的参数
 * @returns {Array}
 */
const handleSalebreakingYardsSortData = (origin, params) => {
    var dest = [];

    if (!_.isEmpty(params.sort)) {

        // 是否有分类筛选参数，如果有
        _.forEach(params.sort.split(','), function(sortParam) {
            _.forEach(origin, function(value) {

                // 判断是否在这组数据里面
                if (!_.isEmpty(_.find(value.sort_id.split(','), o => {
                    return o === sortParam;
                }))) {

                    // 如果在某组数据里面，组合数据退出循环
                    _.forEach(value.sub, function(subValue) {
                        let size = {};

                        size.checked =
                            (parseInt(params.size, 10) === parseInt(subValue.size_id, 10)) ? true : false;
                        size.href = handleFilterUrl(params, {size: subValue.size_id});
                        size.name = subValue.size_name;

                        dest.push(size);
                    });
                    return false;
                }
            });
        });
    } else { // 如果没有筛选参数，返回所有分类
        _.forEach(origin, function(value) {
            _.forEach(value.sub, function(subValue) {
                let size = {};

                size.checked = (parseInt(params.size, 10) === parseInt(subValue.size_id, 10)) ? true : false;
                size.href = handleFilterUrl(params, {size: subValue.size_id});
                size.name = subValue.size_name;

                dest.push(size);
            });
        });
    }

    return _.uniqWith(dest, _.isEqual);
};

/**
 * 处理一般筛选数据
 * @param origin 要处理的筛选数据 filter
 * @param params 当前 URL 中已有的参数，处理选中状态使用
 * @returns {{}}
 */
exports.handleSaleFilterData = (origin, params) => {

    var dest = {};

    dest.brand = {};
    dest.price = [];
    dest.gender = [];

    dest.brand.default = [];
    dest.brand.brandsShow = [];

    dest.brand.brandIndex = [];

    dest.brand.showMore = true;
    dest.brand.showMulti = true;

    dest.checkedConditions = {};
    dest.checkedConditions.conditions = [];


    // 品牌索引数据处理
    dest.brand.brandIndex = [];

    dest.brand.brandIndex[0] = {
        index: 'all',
        name: '全部'
    };

    dest.brand.brandIndex[1] = {
        index: '0-9',
        name: '0~9'
    };

    for (let i = 65; i < 91; i++) {
        dest.brand.brandIndex.push({
            index: String.fromCharCode(i).toLowerCase(),
            name: String.fromCharCode(i)
        });
    }

    // 品牌数据处理
    if (!_.isEmpty(origin.brand)) {
        let count = 0;

        _.forEach(origin.brand, function(value) {
            let brand = {};

            brand.checked = (parseInt(params.brand, 10) === parseInt(value.id, 10)) ? true : false;
            brand.href = handleFilterUrl(params, {brand: value.id});
            brand.name = value.brand_name;
            brand.key = value.brand_domain;
            brand.id = value.id;

            if (!_.isEmpty(value.brand_alif)) {
                if (!_.isNaN(parseInt(value.brand_alif, 10))) {
                    brand.index = '0-9';
                } else {
                    brand.index = value.brand_alif.toLowerCase();
                }
            }

            if (count < 10) {
                dest.brand.default.push(brand);
            }

            dest.brand.brandsShow.push(brand);
            count++;
        });
    }

    // 来排排序
    dest.brand.brandsShow = _.sortBy(dest.brand.brandsShow, function(o) {
        return o.index;
    });

    // 处理 价格 筛选数据
    if (!_.isEmpty(origin.priceRange)) {
        _.forEach(origin.priceRange, function(value, key) {
            let price = {
                checked: (params.price === key) ? true : false,
                href: handleFilterUrl(params, {price: key}),
                name: value
            };

            dest.price.push(price);
        });
    }

    // 处理频道数据
    for (let i = 0; i < 2; i++) {
        dest.gender[i] = {};

        dest.gender[i].checked = false;
    }

    dest.gender[0].name = 'BOYS';
    dest.gender[0].href = handleFilterUrl(params, {gender: '1,3'});
    dest.gender[0].checked = (params.gender === '1,3') ? true : false;
    dest.gender[1].name = 'GIRLS';
    dest.gender[1].href = handleFilterUrl(params, {gender: '2,3'});
    dest.gender[1].checked = (params.gender === '2,3') ? true : false;

    // 最新降价数据处理
    if (parseInt(params.saleType, 10) === 3) {
        dest.discount = handleSaleNewSaleSortData(params);

        // 最新降价筛选数据处理
        dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
            handleCheckedData(params, dest.discount, 'p_d'));
    }

    // 断码区尺码数据处理
    if (!_.isEmpty(origin.size) && params.saleType === '1') {
        dest.size = handleSalebreakingYardsSortData(origin.size, params);

        // 处理断码区尺码筛选数据
        dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
            handleCheckedData(params, dest.size, 'size'));
    }

    // 清除所有选中数据
    dest.checkedConditions.clearUrl = '?';

    // 处理频道筛选数据
    dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
        handleCheckedData(params, dest.gender, 'gender'));

    // 处理品牌筛选数据
    // dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
    //     handleCheckedData(params, dest.brand.brandsShow, 'brand'));
    dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
        handleBrandCheckedData(params, dest.brand.brandsShow));

    // 处理价格筛选数据
    dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
        handleCheckedData(params, dest.price, 'price'));

    return dest;
};

/**
 * 处理折扣专区活动数据
 * @param origin 原始数据
 * @param channel 频道 boys girls kids lifestyle
 * @returns {{}}
 */
exports.handleSaleActivityData = (origin, channel) => {
    var dest = {};

    dest.big = [];
    dest.normal = [];
    _.forEach(origin, function(value, key) {
        let activity = {
            link: helpers.urlFormat('/product/sale/discount/detail', {id: value.id, channel: channel}),
            img: value.cover_url,
            time: processTime(parseInt(value.left_time, 10) * 1000),
            brand: value.logo_url,
            title: value.title
        };

        activity = Object.assign(activity, discountSplit(value.promotion_name));

        if (key < 3) {
            dest.big.push(activity);
        } else if (key < 27) {
            dest.normal.push(activity);
        }
    });
    return dest;
};

/**
 * 处理折扣专区标题折扣倒计时等数据
 * @param origin 要处理的原始数据
 * @returns {{}}
 */
exports.handleDiscountTitleData = (origin) => {
    var dest = {};

    dest.title = origin.title;
    dest.up = true;

    // dest.time = processTimes(origin.left_time);
    dest.time = parseInt(origin.left_time, 10) * 1000;
    Object.assign(dest, discountSplit(origin.promotion_name));

    return dest;
};

/**
 * 处理首页 banner 数据
 * @param origin 要处理的原始数据
 * @returns {{}}
 */
exports.handleSaleBannerData = (origin) => {
    var dest = {};

    dest.list = [];
    _.forEach(origin, function(value) {
        if (value.template_name === 'focus') {
            _.forEach(value.data, function(subValue) {
                let banner = {};

                banner.bannerHeight = 450;
                banner.href = subValue.url;
                banner.img = subValue.src;

                dest.list.push(banner);
            });
        }

    });

    return dest;
};

/**
 * 处理首页 banner 小图 只取前三张
 * @param origin 要处理的原始数据
 * @returns {Array}
 */
exports.handleSaleBannerSmallData = (origin) => {
    var dest = [];
    let count = 0;

    _.forEach(origin, function(value) {
        if (value.template_name === 'threePicture') {
            _.forEach(value.data, function(picList) {
                if (count++ < 3) {
                    let smallPic = {};

                    smallPic.link = picList.url;
                    smallPic.icon = picList.src;
                    smallPic.title = picList.title;
                    smallPic.desc = picList.alt;

                    dest.push(smallPic);
                }
            });
        }
    });

    return dest;
};

/**
 * 处理首页楼层分类数据
 * 修改为取大类前 4 个
 * @param origin 要处理的原始数据
 * @param saleType 获取数据分属哪个类目：断码区，会员专享，折扣专场等
 * @param channel 频道
 * @param breakingSizeSort 为断码去额外拼接参数，接口比较垃圾嘛，没办法
 * @returns {{}}
 */
exports.handleSaleCategoryData = (origin, saleType, channel, breakingSizeSort) => {

    let dest = {};

    // navItem 处理
    dest.navItem = [];
    dest.navItem[0] = {};
    dest.navItem[0].title = '今日推荐';
    dest.navItem[0].vip = true;

    let urlLocation = {};

    // title urlLocation 处理
    switch (saleType) {
        case '1':
            dest.title = '断码区';
            urlLocation.url = '?saleType=' + saleType + '&order=s_t_desc&channel=' + channel +
                '&breakSize=' + breakingSizeSort.breakSize + '&breakSort=' + breakingSizeSort.breakSort;
            urlLocation.limit = 14;
            dest.urlLocation = dest.navItem[0].urlLocation = urlLocation.url + `&limit=${urlLocation.limit}`;
            break;
        case '2':
            dest.title = 'VIP会员专享';
            urlLocation.url = '?saleType=' + saleType + '&order=s_t_desc&channel=' + channel;
            urlLocation.limit = 11;
            dest.urlLocation = dest.navItem[0].urlLocation = urlLocation.url + `&limit=${urlLocation.limit}`;
            break;
        case '3':
            dest.title = '最新降价';
            urlLocation.url = '?saleType=0&order=s_t_desc&channel=' + channel;
            urlLocation.limit = 14;
            dest.urlLocation = dest.navItem[0].urlLocation = urlLocation.url + `&limit=${urlLocation.limit}`;
            break;
        default:
            break;
    }

    let count = 0;

    _.forEach(origin, (value) => {

        if (count++ < 4) {
            let nav = {};

            nav.urlLocation = urlLocation.url + '&sort=' + value.relation_parameter.sort +
                `&limit=${(urlLocation.limit + 1)}`;
            nav.title = value.category_name;
            nav.newDiscount = true;

            dest.navItem.push(nav);
        }
    });

    return dest;
};

/**
 * 处理断码区尺码数据，输出整合后的筛选条件
 * @param origin
 */
exports.handleSaleBreakingSizeData = (origin) => {
    let dest = {};

    dest.breakSize = '';
    dest.breakSort = '';

    _.forEach(origin, value => {
        dest.breakSort += value.sort_id;

        _.forEach(value.sub, subValue => {
            dest.breakSize += subValue.size_id + ',';
        });
    });

    return dest;
};