/*
 * Juick
 * Copyright (C) 2008-2011, Ugnich Anton
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.juick.server;

import com.juick.User;
import com.juick.server.helpers.Auth;
import com.juick.server.helpers.EmailOpts;
import com.juick.server.helpers.UserInfo;
import com.juick.util.UserUtils;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.util.StringUtils;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;

/**
 * @author Ugnich Anton
 */
public class UserQueries {

    static final String ABCDEF = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static class UserMapper implements RowMapper<User> {
        @Override
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setUid(rs.getInt(1));
            user.setName(rs.getString(2));
            user.setBanned(rs.getBoolean(3));
            return user;
        }
    }

    public static String getSignUpHashByJID(JdbcTemplate sql, String jid) {
        String hash;
        try {
            hash = sql.queryForObject("SELECT loginhash FROM jids WHERE jid=? AND user_id IS NULL",
                    String.class, jid);
        } catch (EmptyResultDataAccessException e) {
            hash = UUID.randomUUID().toString();
            sql.update("INSERT INTO jids(jid,loginhash) VALUES (?,?)", jid, hash);
        }
        return hash;
    }

    public static String getSignUpHashByTelegramID(JdbcTemplate sql, Long telegramId, String username) {
        try {
            return sql.queryForObject("SELECT loginhash FROM telegram WHERE tg_id=? AND user_id IS NULL",
                    String.class, telegramId);
        } catch (EmptyResultDataAccessException e) {
            String hash = UUID.randomUUID().toString();
            sql.update("INSERT INTO telegram(tg_id, loginhash, tg_name) VALUES (?, ?, ?)", telegramId, hash, username);
            return hash;
        }
    }

    public static int createUser(JdbcTemplate sql, String username, String password) {
        KeyHolder holder = new GeneratedKeyHolder();
        try {
            sql.update(con -> {
                PreparedStatement stmt = con.prepareStatement("INSERT INTO users(nick,passw) VALUES (?,?)",
                        Statement.RETURN_GENERATED_KEYS);
                stmt.setString(1, username);
                stmt.setString(2, password);
                return stmt;
            }, holder);
        } catch (DuplicateKeyException e) {
            return -1;
        }

        int uid = holder.getKey().intValue();

        sql.update("INSERT INTO useroptions(user_id) VALUES (?)", uid);
        sql.update("INSERT INTO subscr_users(user_id,suser_id) VALUES (2,?)", uid);

        return uid;
    }

    public static Optional<User> getUserByUID(JdbcTemplate sql, int uid) {
        try {
            return Optional.of(sql.queryForObject("SELECT id, nick,banned FROM users WHERE id=?",
                    new UserMapper(), uid));
        } catch (EmptyResultDataAccessException e) {
            return Optional.empty();
        }
    }

    public static User getUserByName(JdbcTemplate sql, String username) {
        try {
            return sql.queryForObject("SELECT id,nick,banned FROM users WHERE nick=?",
                    new UserMapper(),
                    username);
        } catch (EmptyResultDataAccessException e) {
            return null;
        }
    }

    public static User getUserByJID(JdbcTemplate sql, String jid) {
        try {
            return sql.queryForObject("SELECT id,nick,banned FROM users WHERE id=(SELECT user_id FROM jids WHERE jid=?)",
                    new UserMapper(), jid);
        } catch (EmptyResultDataAccessException e) {
            return null;
        }
    }

    public static List<User> getUsersByName(JdbcTemplate sql, List<String> unames) {
        if (!unames.isEmpty()) {
            return sql.query("SELECT id,nick,banned FROM users WHERE nick IN (\"" + StringUtils.arrayToDelimitedString(unames.toArray(), "\",\"") + "\")",
                    new UserMapper());
        }
        return Collections.emptyList();
    }

    public static List<User> getUsersByID(JdbcTemplate sql, List<Integer> uids) {
        if (!uids.isEmpty()) {
            return sql.query("SELECT id,nick,banned FROM users WHERE id IN (" + StringUtils.arrayToCommaDelimitedString(uids.toArray()) + ")",
                    new UserMapper());
        }
        return Collections.emptyList();
    }

    public static List<com.juick.User> getUsersByJID(JdbcTemplate sql, List<String> jids) {
        if (!jids.isEmpty()) {
            return sql.query("SELECT users.id,users.nick,jids.jid FROM users "
                            + "INNER JOIN jids ON jids.user_id=users.id "
                            + "WHERE jids.jid IN (\"" + StringUtils.arrayToDelimitedString(jids.toArray(), "\",\"") + "\")",
                    (rs, rowNum) -> {
                        com.juick.User user = new com.juick.User();
                        user.setUid(rs.getInt(1));
                        user.setName(rs.getString(2));
                        user.setJid(rs.getString(3));
                        return user;
                    });
        }
        return Collections.emptyList();
    }

    public static List<String> getJIDsbyUID(JdbcTemplate sql, int uid) {
        return sql.queryForList("SELECT jid FROM jids WHERE user_id=? AND active=1", String.class, uid);
    }

    public static int getUIDbyJID(JdbcTemplate sql, String jid) {
        try {
            return sql.queryForObject("SELECT user_id FROM jids WHERE jid=?", Integer.class, jid);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static int getUIDbyName(JdbcTemplate sql, String uname) {
        try {
            return sql.queryForObject("SELECT id FROM users WHERE nick=?", Integer.class, uname);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static int getUIDbyHash(JdbcTemplate sql, String hash) {
        try {
            return sql.queryForObject("SELECT user_id FROM logins WHERE hash=?", Integer.class, hash);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static com.juick.User getUserByHash(JdbcTemplate sql, String hash) {
        try {
            User user = sql.queryForObject("SELECT logins.user_id,users.nick, users.banned FROM logins " +
                            "INNER JOIN users ON logins.user_id=users.id WHERE logins.hash=?",
                    new UserMapper(), hash);
            user.setAuthHash(hash);
            return user;
        } catch (EmptyResultDataAccessException e) {
            return new User();
        }
    }

    public static String getHashByUID(JdbcTemplate sql, int uid) {
        try {
            return sql.queryForObject("SELECT hash FROM logins WHERE user_id=?", String.class, uid);
        } catch (EmptyResultDataAccessException e) {
            String hash = UserUtils.generateHash(16);
            sql.update(con -> {
                PreparedStatement stmt = con.prepareStatement("INSERT INTO logins(user_id,hash) VALUES (?,?)");
                stmt.setInt(1, uid);
                stmt.setString(2, hash);
                return stmt;
            });
            return hash;
        }
    }

    public static int checkPassword(JdbcTemplate sql, String username, String password) {
        try {
            String realPassword = sql.queryForObject("SELECT passw FROM users WHERE nick=?", String.class, username);
            if (realPassword.equals(password)) {
                User user = UserQueries.getUserByName(sql, username);
                if (user != null) {
                    return user.getUid();
                } else {
                    return -1;
                }
            } else {
                return -1;
            }
        } catch (EmptyResultDataAccessException e) {
            return -1;
        }
    }

    public static boolean updatePassword(JdbcTemplate sql, User user, String newPassword) {
        return user.getUid() > 0 && sql.update("UPDATE users SET passw=? WHERE id=?", newPassword, user.getUid()) > 0;
    }

    public static String updateSecretEmail(JdbcTemplate sql, User user) {
        String newHash = UserUtils.generateHash(16);
        if (sql.update("INSERT INTO mail(user_id,hash) VALUES (?,?) ON DUPLICATE KEY UPDATE hash=?", user.getUid(), newHash, newHash) > 0) {
            return newHash;
        }
        return org.apache.commons.lang3.StringUtils.EMPTY;
    }

    public static int getUserOptionInt(JdbcTemplate sql, int uid, String option, int defaultValue) {
        try {
            return sql.queryForObject("SELECT " + option + " FROM useroptions WHERE user_id=?", Integer.class, uid);
        } catch (EmptyResultDataAccessException e) {
            return defaultValue;
        }
    }

    public static void setUserOptionInt(JdbcTemplate sql, int uid, String option, int value) {
        sql.update("UPDATE useroptions SET " + option + "=? WHERE user_id=?", value, uid);
    }

    public static UserInfo getUserInfo(JdbcTemplate sql, User user) {
        try {
            return sql.queryForObject("SELECT fullname,country,url,descr FROM usersinfo WHERE user_id=?", ((rs, rowNum) -> {
                UserInfo info = new UserInfo();
                info.setFullName(rs.getString(1));
                info.setCountry(rs.getString(2));
                info.setUrl(rs.getString(3));
                info.setDescription(rs.getString(4));
                return info;
            }), user.getUid());
        } catch (EmptyResultDataAccessException e) {
            return new UserInfo();
        }
    }

    public static boolean updateUserInfo(JdbcTemplate sql, User user, UserInfo info) {
        return sql.update("INSERT INTO usersinfo(user_id,fullname,country,url,descr) VALUES (?,?,?,?,?) " +
                        "ON DUPLICATE KEY UPDATE fullname=?,country=?,url=?,descr=?", user.getUid(), info.getFullName(),
                info.getCountry(), info.getUrl(), info.getDescription(), info.getFullName(),
                info.getCountry(), info.getUrl(), info.getDescription()) > 0;
    }

    public static boolean getCanMedia(JdbcTemplate sql, int uid) {
        try {
            int res = sql.queryForObject("SELECT users.lastphoto-UNIX_TIMESTAMP() FROM users WHERE id=?",
                    Integer.class, uid);
            return res < 3600;
        } catch (EmptyResultDataAccessException e) {
            return false;
        }
    }

    public static boolean isInWL(JdbcTemplate sql, int uid, int check) {
        try {
            return sql.queryForObject("SELECT 1 FROM wl_users WHERE user_id=? AND wl_user_id=?",
                    Integer.class, uid, check) == 1;
        } catch (EmptyResultDataAccessException e) {
            return false;
        }
    }

    public static boolean isInBL(JdbcTemplate sql, int uid, int check) {
        try {
            return sql.queryForObject("SELECT 1 FROM bl_users WHERE user_id=? AND bl_user_id=?",
                    Integer.class, uid, check) == 1;
        } catch (EmptyResultDataAccessException e) {
            return false;
        }
    }

    public static boolean isInBLAny(JdbcTemplate sql, int uid, int uid2) {
        try {
            return sql.queryForObject("SELECT 1 FROM bl_users "
                    + "WHERE (user_id=? AND bl_user_id=?) "
                    + "OR (user_id=? AND bl_user_id=?)", new Object[]{uid, uid2, uid2, uid}, Integer.class) == 1;
        } catch (EmptyResultDataAccessException e) {
            return false;
        }
    }

    public static List<Integer> checkBL(JdbcTemplate sql, int visitor, List<Integer> uids) {
        if (!uids.isEmpty()) {
            return sql.queryForList("SELECT user_id FROM bl_users WHERE bl_user_id=? and user_id IN (" +
                    StringUtils.collectionToCommaDelimitedString(uids) + ")", Integer.class, visitor);
        } else {
            return new ArrayList<>();
        }
    }

    public static boolean isSubscribed(JdbcTemplate sql, int uid, int check) {
        try {
            return sql.queryForObject("SELECT 1 FROM subscr_users WHERE suser_id=? AND user_id=?",
                    Integer.class, uid, check) == 1;
        } catch (EmptyResultDataAccessException e) {
            return false;
        }
    }

    public static List<Integer> getUserRead(JdbcTemplate sql, int uid) {
        return sql.queryForList("SELECT user_id FROM subscr_users WHERE suser_id=?", Integer.class, uid);
    }

    public static List<com.juick.User> getUserReadLeastPopular(JdbcTemplate sql, int uid, int cnt) {
        return sql.query("SELECT users.id,users.nick FROM (subscr_users " +
                        "INNER JOIN users_subscr ON (subscr_users.suser_id=? " +
                        "AND subscr_users.user_id=users_subscr.user_id)) INNER JOIN users " +
                        "ON subscr_users.user_id=users.id ORDER BY cnt LIMIT ?",
                (rs, num) -> {
                    com.juick.User u = new com.juick.User();
                    u.setUid(rs.getInt(1));
                    u.setName(rs.getString(2));
                    return u;
                }, uid, cnt);
    }

    public static List<User> getUserReaders(JdbcTemplate sql, int uid) {
        return sql.query("SELECT users.id, users.nick FROM subscr_users " +
                        "INNER JOIN users ON subscr_users.suser_id=users.id " +
                        "WHERE subscr_users.user_id=? ORDER BY users.nick",
                (rs, num) -> {
                    com.juick.User u = new com.juick.User();
                    u.setUid(rs.getInt(1));
                    u.setName(rs.getString(2));
                    return u;
                }, uid);
    }

    public static List<User> getUserFriends(JdbcTemplate sql, int uid) {
        return sql.query("SELECT users.id,users.nick FROM subscr_users " +
                        "INNER JOIN users ON subscr_users.user_id=users.id " +
                        "WHERE subscr_users.suser_id=? AND users.id!=? " +
                        "ORDER BY users.nick",
                (rs, num) -> {
                    com.juick.User u = new com.juick.User();
                    u.setUid(rs.getInt(1));
                    u.setName(rs.getString(2));
                    return u;
                }, uid, uid);
    }

    public static List<com.juick.User> getUserBLUsers(JdbcTemplate sql, int uid) {
        return sql.query("SELECT users.id,users.nick FROM users INNER JOIN bl_users " +
                        "ON(bl_users.bl_user_id=users.id) WHERE bl_users.user_id=? ORDER BY users.nick",
                (rs, num) -> {
                    com.juick.User u = new com.juick.User();
                    u.setUid(rs.getInt(1));
                    u.setName(rs.getString(2));
                    return u;
                }, uid);
    }

    public static boolean linkTwitterAccount(JdbcTemplate sql, User user, String accessToken,
                                             String accessTokenSecret, String screenName) {
        if (sql.update("INSERT INTO twitter(user_id,access_token,access_token_secret,uname) " +
                        "VALUES (?,?,?,?)" +
                        " ON DUPLICATE KEY UPDATE access_token=?,access_token_secret=?,uname=?",
                user.getUid(), accessToken, accessTokenSecret, screenName, accessToken, accessTokenSecret, screenName) > 0) {
            return sql.update("INSERT INTO subscr_users(user_id,suser_id,jid) " +
                    "VALUES (?,1741,'juick\\@twitter.juick.com')", user.getUid()) > 0;
        }
        return false;

    }

    public static int getStatsIRead(JdbcTemplate sql, int uid) {
        try {
            return sql.queryForObject("SELECT COUNT(*) FROM subscr_users WHERE suser_id=?", Integer.class, uid);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static int getStatsMyReaders(JdbcTemplate sql, int uid) {
        try {
            return sql.queryForObject("SELECT COUNT(*) FROM subscr_users WHERE user_id=?", Integer.class, uid);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static int getStatsMessages(JdbcTemplate sql, int uid) {
        try {
            return sql.queryForObject("SELECT COUNT(*) FROM messages WHERE user_id=?", Integer.class, uid);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public static int getStatsReplies(JdbcTemplate sql, int uid) {
        try {
            return sql.queryForObject("SELECT COUNT(*) FROM replies WHERE user_id=?", Integer.class, uid);
        } catch (EmptyResultDataAccessException e) {
            return 0;
        }
    }

    public enum ActiveStatus {
        Inactive,
        Active
    }

    public static boolean setActiveStatusForJID(JdbcTemplate sql, String JID, ActiveStatus jidStatus) {
        User user = getUserByJID(sql, JID);
        if (user != null) {
            return sql.update(con -> {
                PreparedStatement preparedStatement = con.prepareStatement(
                        "UPDATE jids SET active=? WHERE user_id=? AND jid=?");
                int newStatus = jidStatus == ActiveStatus.Active ? 1 : 0;
                preparedStatement.setInt(1, newStatus);
                preparedStatement.setInt(2, user.getUid());
                preparedStatement.setString(3, JID);
                return preparedStatement;

            }) >= 0;
        }
        return false;
    }

    public static List<String> getAllJIDs(JdbcTemplate sql, User user) {
        return sql.queryForList("SELECT jid FROM jids WHERE user_id=?", String.class, user.getUid());
    }

    public static List<Auth> getAuthCodes(JdbcTemplate sql, User user) {
        return sql.query("SELECT account,authcode FROM auth WHERE user_id=? AND protocol='xmpp'",
                (rs, num) -> new Auth(rs.getString(1), rs.getString(2)), user.getUid());
    }

    public static List<String> getEmails(JdbcTemplate sql, User user) {
        return sql.queryForList("SELECT email FROM emails WHERE user_id=?", String.class, user.getUid());
    }

    public static EmailOpts getEmailOpts(JdbcTemplate sql, User user) {
        try {
            return sql.queryForObject("SELECT email,subscr_hour FROM emails WHERE user_id=? AND subscr_hour IS NOT NULL",
                    (rs, num) -> new EmailOpts(rs.getString(1), rs.getInt(2)), user.getUid());
        } catch (EmptyResultDataAccessException e) {
            return null;
        }
    }

    public static String getEmailHash(JdbcTemplate sql, User user) {
        try {
            return sql.queryForObject("SELECT hash FROM mail WHERE user_id=?", String.class, user.getUid())
                    + "@mail.juick.com";
        } catch (EmptyResultDataAccessException e) {
            return org.apache.commons.lang3.StringUtils.EMPTY;
        }
    }
}