/**
 *
 * @author: shijian<jian.shi@yoho.cn>
 * @date: 17/5/31
 */

'use strict';
const _ = require('lodash');
const Router = require('koa-router');
const moment = require('moment');
const pager = require('../utils/pager');
const Mysql = require('../../../lib/mysql-promise');
const Promise = require('bluebird');
const r = new Router();
const rp = require('request-promise');
const config = require('../../../config/config');
const ExpandModel = require('../models/expandModel');
const singleBrandKeyPre = config.singleBrandKeyPre;
const singleSortKeyPre = config.singleSortKeyPre;
const qs = require('querystring');
const lestGoodsNum = 3;

const multiAsync=(multi)=>{
    return multi.execAsync().then(function(res) {
        return res;
    });
}

//查看
const getDataList = async(ctx, key, page, limit)=>{
    let multi = ctx.redis.multi();
    let start = (page-1)*limit;
    let end = (page)*limit-1;
    multi.lrange(key, start, end).LLEN(key);
    return multiAsync(multi);
}

const getDataValues = async(ctx, arr)=>{
    let multi = ctx.redis.multi();
    arr.forEach(item=>{
        multi.get(item);
    });
    return multiAsync(multi);
}
//删除
const delDataValues = async(ctx, arr)=>{
    let multi = ctx.redis.multi();
    arr.forEach(item=>{
        let key = `keywords_mana:${item}`;
        multi.del(key).lrem('keywords_mana_list', 1, key);
    });
    return multiAsync(multi);
}
//添加
const addDataValues = async(ctx, value)=>{
    let multi = ctx.redis.multi();
    let key=`keywords_mana:${value}`;
    multi.set(key, value);
    multi.lrem('keywords_mana_list', 1, key).lpush('keywords_mana_list', key);
    
    return multiAsync(multi);
}
//编辑
const editDataValues = async(ctx, value, oldValue)=>{
    try{
        await delDataValues(ctx, [oldValue]);
        await addDataValues(ctx, value);
        return true;
    }catch(e){
        return false;
    }
    
}
//搜索
const searchDataValues = async(ctx, value)=>{
    let multi = ctx.redis.multi();
    let key=`keywords_mana:*${value}*`;
    multi.KEYS(key);
    return multiAsync(multi);
}

const mgets = async(ctx, item) => {
    let redis = ctx.redis;
    let operation = [];
    item = _.uniq(item);

    if (item.length <= 0) {
        return Promise.resolve({});
    }

    return redis.mgetAsync(item).then(d => {
        let ddata = {};

        _.each(item, (el, index) => {
            ddata[el] = d[index];
        });

        return ddata;
    });
};

r.get('/', async(ctx) => {
    let resData = {};
    let q = ctx.request.query,
    page = parseInt(`0${ctx.query.page}`, 10) || 1,
    limit = parseInt(`0${ctx.query.limit}`, 10) || 10;
    let r = await getDataList(ctx, "keywords_mana_list", page, limit);
    let result = [];
    if(r[0].length)result = await getDataValues(ctx, r[0]);
    let total = r[1];
    resData.pager = pager(Math.floor((total - 1) / limit) + 1, ctx.query);
    resData.tabs = result;
    await ctx.render('action/keywords', resData);
});

r.get('/delKeywords', async(ctx) => {
    let q = ctx.request.query;
    let keys = JSON.parse(q['keywords']);
    try{
        await delDataValues(ctx, keys);
        ctx.body = {
            code: 200,
            message: 'success',
            data: ''
        };
    }catch(e){
        ctx.body = {
            code: 500,
            message: 'fail',
            data: ''
        };
    }    
});

r.get('/addKeywords', async(ctx) => {
    let q = ctx.request.query;
    let key = q['keywords'];
    try{
        await addDataValues(ctx, key);
        ctx.body = {
            code: 200,
            message: 'success',
            data: ''
        };
    }catch(e){
        ctx.body = {
            code: 500,
            message: 'fail',
            data: ''
        };
    }    
});

r.get('/editKeywords', async(ctx) => {
    let q = ctx.request.query;
    let key = JSON.parse(q['keywords']);
    try{
        await editDataValues(ctx, key[0], key[1]);
        ctx.body = {
            code: 200,
            message: 'success',
            data: ''
        };
    }catch(e){
        ctx.body = {
            code: 500,
            message: 'fail',
            data: ''
        };
    }    
});

r.get('/searchKeywords', async(ctx) => {
    let q = ctx.request.query;
    let key = q['association'];
    let r = await searchDataValues(ctx, key);
    let result = [];
    if(r[0].length)result = await getDataValues(ctx, r[0]);
    ctx.body = {
        code: 200,
        message: 'success',
        data: result,
        total:1
    }; 
});



const insertWord = (keyword, mysql) => {
    return mysql.query(`SELECT id FROM seo_keywords WHERE keyword = ? AND status = 1`, [keyword]).then(d => {
        console.log(keyword, d, '--+++++++++++++++++++++++-');
        if (d.length <= 0) {
            return mysql.query(
                `INSERT INTO seo_keywords SET keyword = ?, is_push = ?, yoho_goods_num= ?, add_time = ?`,
                [keyword, 1, -2, moment().unix()]
            );
        }
        return d;
    });
}

const getRootKeyword = (ids, mysql) => {
    let len = ids.length;
    let marks = [];

    if (len <= 0) {
        return Promise.resolve({});
    }

    for(let i = 0; i < len; i++) {
        marks.push('?');
    } 
    return mysql.query(`SELECT id, keyword FROM seo_keywords_root WHERE id IN (${marks.join(',')}) AND status = 1;`, ids).then(d => {
        let ddata = {};

        _.each(d, (item) => {
            ddata[item.id] = item.keyword;
        });

        return ddata;
    });
}

//redis关键词同步到mysql
r.get('/syncWord', async(ctx) => {
    let mysql = new Mysql();

    return getDataList(ctx, "keywords_mana_list", 0, -1).then(d => {
        return getDataValues(ctx, d[0]);
    }).then(ddata => {
        return Promise.map(ddata, (word) => insertWord(word, mysql), {concurrency: 15});
    }).then(d => {
        return ctx.body = {
            code: 200,
            message: 'success',
            data: d
        }; 
    });
});

r.get('/expand', async(ctx) => {
    let resData = {};
    let q = ctx.request.query;
    let query = q.query || '';
    let page = parseInt(`0${ctx.query.page}`, 10) || 1;
    let limit = parseInt(`0${ctx.query.limit}`, 10) || 10;
    let mysql = new Mysql();
    let total = 0;
    let typeList = [
        {
            type: 'keyword',
            name: '关键词'
        },
        {
            type: 'wordroot',
            name: '词根ID'
        },
        {
            type: 'goodnum',
            name: '商品数'
        }
    ];
    let type = q.type || typeList[0].type;
    let typeName = _.result(_.find(typeList, {'type': type}), 'name') || typeList[0].name;
    let wheres = '';
    let conditions = [];

    switch (query && type) {
        case 'keyword': 
            wheres = ` AND keyword like '%%${query}%'`;
            break;
        case 'wordroot': 
            wheres += ' AND root_id = ?'
            conditions.push(query);
            break;
        case 'brand': 
            wheres += ' AND brand_id = ?'
            conditions.push(query);
            break;
        case 'sort': 
            wheres += ' AND sort_id = ?'
            conditions.push(query);
            break;
        case 'goodnum': 
            wheres += ' AND yoho_goods_num >= ?'
            conditions.push(query);
            break;
    }

    let d = await mysql.query(`SELECT COUNT(*) as total FROM seo_keywords WHERE status = 1 ${wheres}`, conditions);

    total = d[0] && d[0].total || 0;
    conditions.push((page - 1) * limit, limit);

    d = await mysql.query(`SELECT * FROM seo_keywords WHERE status = 1 ${wheres} ORDER BY id DESC limit ?, ?`, conditions);

    let sortIds = [];
    let brandIds = [];
    let rootIds = [];

    resData.pager = pager(Math.floor((total - 1) / limit) + 1, ctx.query);

    _.each(d, (val) => {
        if (val.sort_id) {
            sortIds.push(`${singleSortKeyPre}${val.sort_id}`);
        }

        if (val.brand_id) {
            brandIds.push(`${singleBrandKeyPre}${val.brand_id}`);
        }

        if (val.root_id) {
            rootIds.push(val.root_id);
        }
    });

    brandIds = await mgets(ctx, brandIds);
    sortIds = await mgets(ctx, sortIds);
    rootIds = await getRootKeyword(rootIds, mysql);

    resData.tabs = _.map(d, (elem) => {
        return Object.assign({}, elem, {
            root: rootIds[elem.root_id],
            brand: brandIds[`${singleBrandKeyPre}${elem.brand_id}`],
            sort: sortIds[`${singleSortKeyPre}${elem.sort_id}`],
            is_push: elem.is_push ? '是' : '否',
            add_time:  elem.add_time && moment(elem.add_time * 1000).format('YYYY-MM-DD HH:mm'),
        });
    });

    resData.typeList = typeList;
    resData.typeName = typeName;
    resData.type = type;
    resData.query = query;

    return ctx.render('action/keywords/expand', resData);
});

r.post('/expand/del', async(ctx) => {
    let q = ctx.request.body;
    let ids = q.ids && JSON.parse(q.ids) || [];

    let len = ids.length;
    let marks = [];

    if (len <= 0) {
        return ctx.body = {
            code: 400,
            message: 'ids is empty',
            data: ''
        }; 
    }

    let mysql = new Mysql();
    for(let i = 0; i < len; i++) {
        marks.push('?');
    } 

    return mysql.query(`UPDATE seo_keywords SET status = 0 WHERE id IN (${marks.join(',')})`, ids).then(d => {
        return ctx.body = {
            code: 200,
            message: 'success',
            data: d
        }; 
    });
});

/**
 * [yohobuy-chanping关联词生成]
 * @param  {[type]} '/expand/randWords' [description]
 * @param  {[type]} async(ctx           [description]
 * @return {[type]}                     [description]
 */
r.post('/expand/randWords', async(ctx) => {
    let expandModel = new ExpandModel(ctx);

    return expandModel.getRanData().then(d => {
        return ctx.body = {
            code: 200,
            message: 'success'
        };
    });
});

const baiduUrls = {
    urls: 'http://data.zz.baidu.com/urls',
    update: 'http://data.zz.baidu.com/update',
    del: 'http://data.zz.baidu.com/del'
};
/**
 * 将链接推送到百度站长
 * @param params object {site: 'https://www.yohobuy.com', type: 'mip'} 默认不需要type
 * @param urls
 */
const sendUrlsToBaidu = (params, urls) => {
    let paramsDef = {
        token: config.baiduToken
    };

    // 过滤无效的参数
    _.forEach(params, (val, key) => {
        if (!val) {
            delete params[key];
        }
    });

    qs.escape = (str) => {
        return str;
    };

    let options = {
        url: `${baiduUrls.urls}?${qs.stringify(Object.assign(paramsDef, params), null, null, {})}`,
        headers: {
            'Content-Type': 'text/plain'
        },
        method: 'post',
        form: urls.join('\n'),
        json: true,
        timeout: 10000,
        gzip: true
    };

    return rp(options).then(result => {
        console.log(Object.assign(params, result, {length: urls.length}));
        if (result) {
            return true;
        } else {
            return false;
        }
    });
};
/**
 * 推送urls
 * @params limit url条数
 * @return boolean
 */
const sendUrls = (limit, page) => {

    // 调用limit条未推送关键词
    let mysql = new Mysql();

    return mysql.query(`select id, keyword from seo_keywords where is_push=0 and yoho_goods_num > ${lestGoodsNum} and status=1 order by id asc limit ${(page-1)*limit}, ${limit}`).then(d => {
        let pcPages = [],
            wapPages = [];

        _.forEach(d, (val) => {
            pcPages.push(`https://www.yohobuy.com/chanpin/${val.id}.html`);
            wapPages.push(`https://m.yohobuy.com/chanpin/${val.id}.html`);
        })

        // 根据 site 推送相应站点
        return Promise.all([sendUrlsToBaidu({site: 'https://www.yohobuy.com'}, pcPages),sendUrlsToBaidu({site: 'https://m.yohobuy.com'}, wapPages)]).then(result => {
            let updateSql = `UPDATE seo_keywords SET is_push = 1 WHERE id >= ${_.get(_.first(d), 'id')} and id <= ${_.get(_.last(d), 'id')}  and yoho_goods_num > ${lestGoodsNum} and status=1`;

            // 更新关键词推送状态
            return mysql.query(updateSql).then(updateRes => {
                return updateRes;
            });
        })
    });
}

const getPushTotal = () => {
    let mysql = new Mysql();

    return mysql.query(`select count(id) from seo_keywords where  is_push=0 and yoho_goods_num > ${lestGoodsNum} and status=1`).then(d=>{
        return _.get(d, '0.count(id)', 0);
    });
}

/**
 * 推送url到百度(获取2000条未推送关键词，监测是否还有未推关键词，如果有再推2000，直到全部推送)
 */

r.get('/sendUrl', async(ctx, next) => {
    let result = {
        code: 200,
        message: '暂未开放！'
    };

    let total = await getPushTotal(); // 待推送总数

    let limit = 2000; // 每次推送的条数

    if (total === 0) {
        result.message = '没有需要推送的词！';
    } else {
        let intervalTime = Math.floor(total/limit) + 1;

        // 推送2000条
        let interval = setInterval(() => {
                sendUrls(limit, intervalTime);

            if (--intervalTime < 1) {
                clearInterval(interval);
            }

        }, 1000);
        result.message = `${intervalTime*10} 秒后查看推送结果`;
    }
    ctx.response.body = result;
});
module.exports = r;