/**
 * 品牌页
 * @param params
 * @returns {function()}
 */

'use strict';

const helpers = global.yoho.helpers;

// const utils = '../../../utils';
// const floorProcess = require(`${utils}/floor-process`);

/* 男生频道取品牌广告及热门品牌数据的位置码 */
let CODE_TOPPOS_BOYS = 'ce6ac059493ec26241a8cbe0bfa1b17a';

/* 女生频道取品牌广告及热门品牌数据的位置码 */
let CODE_TOPPOS_GIRLS = 'dac99cdedc1f948e84c145aca561f7d2';

/* 潮童频道取品牌广告及热门品牌数据的位置码 */
let CODE_TOPPOS_KIDS = '713784f93f52bb1a7b93916b2bb15510';

/* 创意生活频道取品牌广告及热门品牌数据的位置码 */
let CODE_TOPPOS_LIFESTYLE = 'f1aa914fd23cbcda71a87de6f5416c75';

module.exports = class extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
    }

    /**
     * 获取频道接口
     */
    _packageAd(params) {
        return this.get({
            url: '/operations/api/v5/resource/get',
            data: {
                content_code: params.contentCode,
                gender: 1,
                limit: 1000,
                page: 1
            },
            api: global.yoho.ServiceAPI,
            param: {
                cache: true
            }
        });
    }

    _packageList(channel) {
        return this.get({
            data: {method: 'app.brand.allBrandList', yh_channel: channel},
            param: {
                cache: true,
                code: 200
            }
        });
    }

    getBrandByChannel(channel) {
        let params = {};

        /* 根据频道调用接口 */
        switch (channel) {
            case '1': // 男生
                params = {
                    contentCode: CODE_TOPPOS_BOYS
                };
                break;
            case '2': // 女生
                params = {
                    contentCode: CODE_TOPPOS_GIRLS
                };
                break;
            case '3': // 潮童
                params = {
                    contentCode: CODE_TOPPOS_KIDS
                };
                break;
            case '4': // 创意生活
                params = {
                    contentCode: CODE_TOPPOS_LIFESTYLE
                };
                break;
            default:
                channel = 1;
                break;
        }

        return this._packageAd(params).then(result => {
            let resu = {
                channel: {
                    channels: [{
                        name: 'Boy',
                        channelName: 'boys'
                    }, {
                        name: 'Girl',
                        channelName: 'girls'
                    }, {
                        name: 'Kid',
                        channelName: 'kids'
                    }, {
                        name: 'Lifestyle',
                        channelName: 'lifestyle'
                    }],
                    topData: {
                        bannerTop: {},
                        hotBrandsScroll: {}
                    },
                    searchUrl: helpers.urlFormat('/brands/search', null),
                    brandPage: true,
                    brandType: '全部品牌',
                    secondBrandType: '新入驻品牌',
                    thirdBrandType: '热门品牌'
                }
            };

            resu.channel.channels[channel - 1].active = true;
            if (result && result.data) {
                if (result.data[0] && result.data[0].data) {
                    // 轮播图资源位
                    let adList = result.data[0].data;
                    let build = [];

                    adList.forEach(ad => {
                        build.push({
                            img: helpers.image(ad.src, 640, 240),
                            url: ad.url
                        });
                    });
                    resu.channel.topData.bannerTop.list = build;
                }

                if (result.data[1] && result.data[1].data) {
                    // 推荐品牌资源位
                    let brandList = result.data[1].data.list || [];
                    let brand = [];

                    brandList.forEach(ad => {
                        brand.push({
                            img: helpers.image(ad.src, 140, 140),
                            url: ad.url,
                            textCn: ad.title
                        });
                    });

                    resu.channel.topData.hotBrandsScroll.name = result.data[1].data.title.title;
                    resu.channel.topData.hotBrandsScroll.list = brand;
                }
            }
            return resu;
        });
    }

    _urlJump(key, row) {

        return {
            1: helpers.urlFormat('', {from: 'search', query: row.brand_name}, 'search'),
            2: helpers.urlFormat('/product/shop', {domain: row.brand_domain}),
            3: helpers.urlFormat('/product/global/list/', {brand: row.global_brand_id})
        }[key];
    }

    getBrandListByChannel(channel) {
        return this._packageList(channel).then(result => {
            let resu = {
                brandList: [],
                newBrandWall: [],
                recommandBrandWall: []
            };

            if (!result || !result.data) {
                return resu;
            }

            /* 按字母'A-Z'分组的品牌列表 */
            let allList = result.data.all_list;

            for (let key in allList) {
                if (key) {
                    let obj = {
                        title: key,
                        list: []
                    };

                    allList[key].forEach(row => {

                        obj.list.push({
                            name: row.brand_name,
                            isHot: row.is_hot === 'Y' ? true : false,
                            isNew: row.is_show_new === 'Y' ? true : false,
                            url: this._urlJump(parseInt(row.type, 10), row)
                        });
                    });
                    resu.brandList.push(obj);
                }
            }

            // 新入驻品牌
            let newList = result.data.new_list;

            for (let key in newList) {
                if (key) {
                    let obj = {
                        list: []
                    };

                    obj.list.push({
                        brandName: newList[key].brand_name,
                        url: this._urlJump(parseInt(newList[key].type, 10), newList[key]),
                        img: helpers.image(newList[key].brand_ico, 186, 115),
                    });
                    resu.newBrandWall.push(obj);
                }
            }

            // 推荐品牌
            let hotList = result.data.hot_list;

            for (let key in hotList) {
                if (key) {
                    let obj = {
                        list: []
                    };

                    obj.list.push({
                        brandName: hotList[key].brand_name,
                        url: this._urlJump(parseInt(hotList[key].type, 10), hotList[key]),
                        img: helpers.image(hotList[key].brand_ico, 186, 115),
                    });
                    resu.recommandBrandWall.push(obj);
                }
            }

            return resu;
        });
    }

    /**
     * 获取搜索的品牌列表
     *
     * @param int $channel 1表示男生频道, 2表示女生频道, 3表示潮童频道, 4表示创意生活频道
     * @return array
     */
    getBrandForSearch(channel) {
        return this.get({
            data: {
                method: 'app.brand.allBrandList',
                yh_channel: channel || 1
            },
            param: {
                cache: true,
                code: 200
            }
        }).then(result => {

            return result;

        });
    }

    /**
     * 品牌搜索历史
     * @param int $uid
     * @author sefon 2016-5-17 12:12:28
     * @return array
     */
    branchSearchHistory(params) {
        return this.get({
            data: {
                method: 'app.search.hotBrandRecords',
                uid: params.uid,
                records: params.records || ''
            },
            param: {code: 200}
        }).then(result => {

            return result;

        });
    }

    addSearchHistory(param) {

        return this.get({
            data: {
                method: 'app.search.hotBrandRecords',
                uid: param.uid,
                records: param.records
            },
            param: {code: 200}
        });
    }

    /**
     * 热搜品牌
     * @author sefon 2016-5-17 12:20:26
     * @return array
     */
    branchSearchHot() {
        return this.get({
            data: {method: 'app.search.hotBrands'},
            param: {
                cache: true,
                code: 200
            }
        }).then(result => {

            return result;

        });
    }

    /**
     * 获取搜索的品牌列表 pagecache重构
     *
     * @param int $channel 1表示男生频道, 2表示女生频道, 3表示潮童频道, 4表示创意生活频道
     * @return array
     */
    branchSearch(params) {
        return Promise.all([

            this.getBrandForSearch(params.channel),

            // branchSearchHistory(params),
            this.branchSearchHot(),

        ]).then(result => {

            let resu = {
                brandPage: true,
                pageFooter: true,
                hot: [],
                history: [],
                brandList: []
            };

            if (result && result[0] && result[0].data) {

                let brandList = result[0].data.all_list;

                let obj = {};

                for (let key in brandList) {
                    if (key) {
                        let build = [];

                        brandList[key].forEach(row => {
                            build.push({
                                name: row.brand_name,
                                isHot: row.is_hot === 'Y' ? true : false,
                                isNew: row.is_show_new === 'Y' ? true : false,
                                url: this._urlJump(parseInt(row.type, 10), row),
                                brandId: row.id,
                                brandDomain: row.brand_domain,
                                searchName: row.brand_name_en + row.brand_name_cn
                            });
                            obj[key] = build;
                        });
                    }
                }

                resu.brandList = JSON.stringify(obj);
            }


            if (result && result[1] && result[1].data) {

                let hotList = result[1].data;

                for (let key in hotList) {
                    if (key) {
                        let obj = {};

                        obj = Object.assign(obj, {
                            name: hotList[key].brandName
                        });
                        resu.hot.push(obj);
                    }
                }
            }

            // if (result && result[1] && result[1].data) {

            //     let hisList = result[1].data;

            //     let obj = [];

            //     let build = {

            //         list: []

            //     };

            //     for (let key in hisList) {

            //         obj.push({
            //             name: hisList[key].searchTerms,
            //             searchTime: hisList[key].searchTime
            //         });

            //     }

            //     build.list = obj;

            //     resu.history = build;

            // }

            return resu;

        });
    }

    delBrandSearchHistory(param) {

        return this.get({
            data: {
                method: 'app.search.clearHotBrandRecords',
                uid: param.uid
            },
            param: {code: 200}
        }).then(result => {

            return result;

        });
    }

    /**
     * [异步获取用户最近搜索词]
     */
    branchSearchHistoryAsync(uid) {
        return this.branchSearchHistory({
            uid
        }).then((result) => {
            let hisList = result.data;

            let obj = [];

            let build = {

                list: []

            };

            for (let key in hisList) {
                if (key) {
                    obj.push({
                        name: hisList[key].searchTerms,
                        searchTime: hisList[key].searchTime
                    });
                }
            }

            build.list = obj;

            return build;
        });
    }
};