/**
 * 文章controller
 * @author: leo <qi.li@yoho.cn>
 * @date: 23/06/2017
 */
const _ = require('lodash');
const camelcase = require('camelcase');
const ArticleModel = require('../models/article');

const POST_SUCCESS = '操作成功';
const GET_SUCCESS = '获取成功';
const INVALID_PARAMS = '参数错误';
const VOTE_REPEAT = '不能给同一位选手重复投票';
const VOTE_MAX = '达到每天投票上限';

const article = {
    /**
     * 文章列表
     * @param req
     * @param res
     * @param next
     */
    list(req, res, next) {
        const query = req.query;
        const actId = query.actId;
        const pageNo = query.pageNo || 1;
        const pageSize = query.pageSize || 10;
        const orderBy = query.orderBy || 'createTime';
        const order = ((query.order || 'desc') + '').toLowerCase();
        const orderByFields = ['createTime', 'goodCount'];

        if (!actId) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (order !== 'asc' && order !== 'desc') {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (orderByFields.indexOf(orderBy) === -1) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        req.ctx(ArticleModel).articleList({
            actId,
            order,
            orderBy,
            pageNo,
            pageSize
        })
        .then(result => {
            let list = [];

            _.each(result, item => {
                let data = {};

                _.each(item, (val, key) => {
                    data[camelcase(key)] = val;
                });
                list.push(data);
            });
            return list;
        })
        .then(list => {
            return req.ctx(ArticleModel).allArticlesNum(actId)
                .then(totalCount => {
                    res.json({
                        code: 200,
                        data: list,
                        pageNo: +pageNo,
                        pageSize: +pageSize,
                        totalCount,
                        totalPage: Math.ceil(totalCount / pageSize),
                        message: GET_SUCCESS
                    });
                });
        })
        .catch(next);

    },

    /**
     * 文章列表无图
     * @param req
     * @param res
     * @param next
     */
    listNoImg(req, res, next) {
        const query = req.query;
        const actId = query.actId;
        const pageNo = query.pageNo || 1;
        const pageSize = query.pageSize || 10;
        const orderBy = query.orderBy || 'createTime';
        const order = ((query.order || 'desc') + '').toLowerCase();
        const orderByFields = ['createTime', 'goodCount', 'id'];

        if (!actId) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (order !== 'asc' && order !== 'desc') {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (orderByFields.indexOf(orderBy) === -1) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        req.ctx(ArticleModel).articleListWithOutImg({
            actId,
            order,
            orderBy,
            pageNo,
            pageSize
        })
            .then(result => {
                let list = [];

                _.each(result, item => {
                    let data = {};

                    _.each(item, (val, key) => {
                        data[camelcase(key)] = val;
                    });
                    list.push(data);
                });
                return list;
            })
            .then(list => {
                req.ctx(ArticleModel).allArticlesNum(actId)
                    .then(totalCount => {
                        res.json({
                            code: 200,
                            data: list,
                            pageNo,
                            pageSize,
                            totalCount,
                            totalPage: Math.ceil(totalCount / pageSize),
                            message: GET_SUCCESS
                        });
                    });
            })
            .catch(next);

    },

    /**
     * 文章列表无用户并且可按日期查询
     * @param req
     * @param res
     * @param next
     */
    listNoUser(req, res, next) {
        const query = req.query;
        const actId = query.actId;
        const pageNo = query.pageNo || 1;
        const pageSize = query.pageSize || 10;
        const orderBy = query.orderBy || 'createTime';
        const order = ((query.order || 'desc') + '').toLowerCase();
        const orderByFields = ['createTime', 'goodCount'];
        const dateTime = query.dateTime || '';
        const limitDate = query.limitDate || '';

        if (!actId) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (order !== 'asc' && order !== 'desc') {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (orderByFields.indexOf(orderBy) === -1) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        req.ctx(ArticleModel).articleListWithoutUser({
            actId,
            order,
            orderBy,
            pageNo,
            pageSize,
            dateTime,
            limitDate
        })
            .then(result => {
                let list = [];

                _.each(result, item => {
                    let data = {};

                    _.each(item, (val, key) => {
                        data[camelcase(key)] = val;
                    });
                    list.push(data);
                });
                return list;
            })
            .then(list => {
                return req.ctx(ArticleModel).allArticlesNumVote(actId)
                    .then(totalCount => {
                        res.json({
                            code: 200,
                            data: list,
                            pageNo: +pageNo,
                            pageSize: +pageSize,
                            total: totalCount.total,
                            total_count: totalCount.total_count,
                            totalPage: Math.ceil(totalCount.total / pageSize),
                            message: GET_SUCCESS
                        });
                    });
            })
            .catch(next);
    },

    /**
     * 获取无图但有用户的文章列表
     * @param req
     * @param res
     * @param next
     */
    listWithUser(req, res, next) {
        const query = req.query;
        const actId = query.actId;
        const pageNo = query.pageNo || 1;
        const pageSize = query.pageSize || 10;
        const orderBy = query.orderBy || 'createTime';
        const order = ((query.order || 'desc') + '').toLowerCase();
        const orderByFields = ['createTime', 'goodCount'];

        if (!actId) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (order !== 'asc' && order !== 'desc') {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        if (orderByFields.indexOf(orderBy) === -1) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }

        req.ctx(ArticleModel).articleListWithUser({
            actId,
            order,
            orderBy,
            pageNo,
            pageSize
        }).then(result => {
            let list = [];

            _.each(result, item => {
                let data = {};

                _.each(item, (val, key) => {
                    data[camelcase(key)] = val;
                });
                list.push(data);
            });
            res.json({
                code: 200,
                data: list
            });
        }).catch(next);
    },

    /**
     * 发布文章
     * @param req
     * @param res
     * @param next
     */
    publish(req, res, next) {
        let newId;
        let errorMsg = '';
        const actId = req.body.actId;
        const imgUrl = req.body.imgUrl;
        const content = req.body.content;

        if (!imgUrl || !content || !actId) {
            errorMsg = INVALID_PARAMS;
        }

        if (errorMsg) {
            return res.json({
                code: 400,
                message: errorMsg
            });
        }

        const params = {
            actId,
            imgUrl,
            content
        };

        req.ctx(ArticleModel).createArticle(params)
            .then(id => {
                newId = id;
                return id;
            })
            .then(id => {
                return req.ctx(ArticleModel)
                          .insertArticleImg(id, imgUrl);
            })
            .then(() => {
                res.json({
                    code: 200,
                    data: {
                        id: newId
                    },
                    message: POST_SUCCESS
                });
            })
            .catch(next);
    },

    /**
     * 发布无图文章(用于小游戏用户记录得分)
     * @param req
     * @param res
     * @param next
     */
    publishWithNoImg(req, res, next) {
        const actId = req.body.actId;
        const userId = req.body.userId;
        const score = req.body.score;

        let errMsg = '';

        if (!userId || !score || !actId) {
            errMsg = INVALID_PARAMS;
        }

        if (errMsg) {
            return res.json({
                code: 400,
                message: errMsg
            });
        }

        return req.ctx(ArticleModel).queryArticleByUserId(actId, userId)
            .then(result => {
                if (result && result.length > 0) { // 用户记录存在的话则更新得分
                    let articleId = result[0].id;
                    let old_score = result[0].good_count;

                    if (old_score < score) { // 判断用户得分如果大于原始得分则更新
                        return req.ctx(ArticleModel).updateArticleById(articleId, score)
                            .then(() => {
                                return res.json({
                                    code: 200,
                                    message: '更新用户得分成功!'
                                });
                            }).catch(next);
                    } else {
                        return res.json({
                            code: 200,
                            message: '用户得分小于原始得分!'
                        });
                    }
                } else { // 用户记录不存在的话则保存用户记录
                    return req.ctx(ArticleModel).createArticleWithoutImg(actId, userId, score)
                        .then(() => {
                            return res.json({
                                code: 200,
                                message: '保存用户得分成功!'
                            });
                        }).catch(next);
                }
            }).catch(next);

    },

    /**
     * 查询单个article详情
     * @param req
     * @param res
     * @param next
     */
    querySingle(req, res, next) {
        let errorMsg = '';
        const actId = req.query.actId;
        const articleId = req.query.articleId;

        if (!actId || !articleId) {
            errorMsg = INVALID_PARAMS;
        }

        if (errorMsg) {
            return res.json({
                code: 400,
                message: errorMsg
            });
        }

        req.ctx(ArticleModel).getSingleArticle(actId, articleId)
            .then(ret => {
                let img_arr = _.map(ret, 'img_url');

                let result = {};
                let final_result = {};

                if (ret.length > 0) {
                    result.id = ret[0].id;
                    result.content = ret[0].content;
                    result.good_count = ret[0].good_count;
                    result.user_id = ret[0].user_id;
                    result.user_name = ret[0].user_name;
                    result.create_time = ret[0].create_time;
                    result.img_url = img_arr;
                }
                _.each(result, (value, key) => {
                    final_result[camelcase(key)] = value;
                });
                res.json({
                    code: 200,
                    data: final_result,
                    message: GET_SUCCESS
                });
            })
            .catch(next);
    },

    /**
     * 通过姓名或者编号查询单个article详情
     * @param req
     * @param res
     * @param next
     */
    queryByCodeName(req, res, next) {
        let errorMsg = '';
        const actId = req.query.actId;
        const codeName = req.query.codeName;

        if (!actId || !codeName) {
            errorMsg = INVALID_PARAMS;
        }

        if (errorMsg) {
            return res.json({
                code: 400,
                message: errorMsg
            });
        }

        req.ctx(ArticleModel).getArticleByCodeName(actId, codeName)
            .then(ret => {
                let img_arr = _.map(ret, 'img_url');

                let result = {};
                let final_result = {};

                if (ret.length > 0) {
                    result.id = ret[0].id;
                    result.content = ret[0].content;
                    result.good_count = ret[0].good_count;
                    result.create_time = ret[0].create_time;
                    result.user_name = ret[0].user_name;
                    result.img_url = img_arr;
                }
                _.each(result, (value, key) => {
                    final_result[camelcase(key)] = value;
                });
                res.json({
                    code: 200,
                    data: final_result,
                    message: GET_SUCCESS
                });
            })
            .catch(next);
    },

    /**
     * 通过articleId查询单个article详情
     * @param req
     * @param res
     * @param next
     */
    queryById(req, res, next) {
        let errorMsg = '';
        const actId = req.query.actId;
        const articleId = req.query.articleId;

        if (!actId || !articleId) {
            errorMsg = INVALID_PARAMS;
        }

        if (errorMsg) {
            return res.json({
                code: 400,
                message: errorMsg
            });
        }

        req.ctx(ArticleModel).getArticleById(actId, articleId)
            .then(ret => {
                let img_arr = _.map(ret, 'img_url');

                let result = {};


                if (ret.length > 0) {
                    result.id = ret[0].id;
                    result.content = ret[0].content;
                    result.good_count = ret[0].good_count;
                    result.create_time = ret[0].create_time;
                    result.user_name = ret[0].user_name;
                    result.img_url = img_arr;
                }
                return result;

            }).then(result => {
                return req.ctx(ArticleModel).getRankById(actId, articleId)
                    .then(ret2 => {
                        result.rank = ret2[0].rownum;
                        let final_result = {};

                        _.each(result, (value, key) => {
                            final_result[camelcase(key)] = value;
                        });
                        res.json({
                            code: 200,
                            data: final_result,
                            message: GET_SUCCESS
                        });
                    });
            }).catch(next);
    },

    /**
     * 通过user_id查找文章
     * @param req
     * @param res
     * @param next
     * @returns {Promise.<T>|*}
     */
    queryByUserId(req, res, next) {
        let errorMsg = '';
        const actId = req.query.actId;
        const userId = req.query.userId;

        if (!actId || !userId) {
            errorMsg = INVALID_PARAMS;
        }

        if (errorMsg) {
            return res.json({
                code: 400,
                message: errorMsg
            });
        }

        return req.ctx(ArticleModel).queryArticleByUserId(actId, userId)
            .then(ret => {
                return res.json({
                    code: 200,
                    data: ret
                });
            }).catch(next);
    },

    /**
     * 文章点赞
     * @param req
     * @param res
     * @param next
     */
    like(req, res, next) {
        const actId = req.body.actId;
        const articleId = req.body.articleId;

        let vote = function() {
            req.ctx(ArticleModel).likeArticle(actId, articleId)
                .then(() => {
                    return req.ctx(ArticleModel)
                        .insertLikeDetail(actId, articleId);
                })
                .then(() => {
                    res.json({
                        code: 200,
                        message: POST_SUCCESS
                    });
                })
                .catch(next);
        };

        if (!actId || !articleId) {
            return res.json({
                code: 400,
                message: INVALID_PARAMS
            });
        }
        const user_ip = req.headers['X-Forwarded-For'] || req.ip || req.connection.remoteAddress;

        // 获取活动投票限制参数
        return req.ctx(ArticleModel).getActLimit(actId).then(actInfo => {
            const {repeat_limit, vote_limit} = actInfo[0];

            // 获取用户IP今日已投票次数
            return req.ctx(ArticleModel).getIpCount(actId, user_ip).then(userCount => {
                if (userCount.length > 0 && userCount[0].vote_count >= vote_limit) {
                    return Promise.reject({code: 201, message: VOTE_MAX});
                }
                if (repeat_limit) {
                    return Promise.resolve();
                }
                return req.ctx(ArticleModel).getArticleIp(actId, articleId, user_ip).then(actCount => {
                    if (actCount.length > 0 && actCount[0].vote_count > 0) {
                        return Promise.reject({code: 203, message: VOTE_REPEAT});
                    }
                    return Promise.resolve();
                });
            });
        }).then(() => {
            return vote();
        }, (result) => {
            return res.json(result);
        }).catch(next);
    }
};


module.exports = article;