package com.juick.api;

import com.juick.Tag;
import com.juick.User;
import com.juick.json.JSONSerializer;
import com.juick.json.MessageSerializer;
import com.juick.server.MessagesQueries;
import com.juick.server.TagQueries;
import com.juick.server.UserQueries;
import com.juick.xmpp.JID;
import com.juick.xmpp.Message;
import com.juick.xmpp.Stream;
import com.juick.xmpp.extensions.JuickMessage;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.StringUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

/**
 *
 * @author ugnich
 */
public class Messages {

    private static final Logger logger = Logger.getLogger(Messages.class.getName());

    JdbcTemplate sql;
    
    MessageSerializer messageSerializer = new MessageSerializer();

    public Messages(JdbcTemplate sql) {
        this.sql = sql;
    }

    void feedMessages(HttpServletRequest request, HttpServletResponse response, List<com.juick.Message> msgs) throws IOException {
        String requestScheme = request.getHeader("X-Scheme");
        if (requestScheme != null) {
            if (Objects.equals(requestScheme, "https")) {
                messageSerializer.setUriScheme(JSONSerializer.URIScheme.Secure);
            }
        }
        String json = messageSerializer.serializeList(msgs);
        Main.replyJSON(request, response, json);
    }

    public void doGetHome(HttpServletRequest request, 
            HttpServletResponse response, int vuid) 
            throws ServletException, IOException {
        int before_mid = Utils.parseInt(request.getParameter("before_mid"), 0);
        List<Integer> mids = MessagesQueries.getMyFeed(sql, vuid, before_mid);
        feedMessages(request, response, MessagesQueries.getMessages(sql, mids));
    }

    public void doGet(HttpServletRequest request, 
            HttpServletResponse response, int vuid)
            throws ServletException, IOException {
        int before_mid = Utils.parseInt(request.getParameter("before_mid"), 0);
        String uname = request.getParameter("uname");
        String popular = request.getParameter("popular");
        String media = request.getParameter("media");
        String tag = request.getParameter("tag");
        List<Integer> mids = new ArrayList<>();
        if (!StringUtils.isEmpty(uname)) {
            User user = UserQueries.getUserByName(sql, uname);
            if (user != null) {
                if (!StringUtils.isEmpty(media)) {
                    mids = MessagesQueries.getUserPhotos(sql, user.getUID(), 0, before_mid);
                } else if (!StringUtils.isEmpty(tag)) {
                    Tag tagObject = TagQueries.getTag(sql, tag, false);
                    if (tagObject != null) {
                        mids = MessagesQueries.getUserTag(sql, user.getUID(), tagObject.TID, 0, before_mid);
                    } else {
                        response.sendError(404);
                    }
                } else {
                    mids = MessagesQueries.getUserBlog(sql, user.getUID(), 0, before_mid);
                }
            } else {
                response.sendError(404);
            }
        } else {
            if (!StringUtils.isEmpty(popular)) {
                mids = MessagesQueries.getPopular(sql, vuid, before_mid);
            } else if (!StringUtils.isEmpty(media)) {
                mids = MessagesQueries.getPhotos(sql, vuid, before_mid);
            } else if (!StringUtils.isEmpty(tag)) {
                Tag tagObject = TagQueries.getTag(sql, tag, false);
                if (tagObject != null) {
                    mids = MessagesQueries.getTag(sql, tagObject.TID, vuid, before_mid, 20);
                } else {
                    response.sendError(404);
                }
            } else {
                mids = MessagesQueries.getAll(sql, vuid, before_mid);
            }
        }
        feedMessages(request, response, MessagesQueries.getMessages(sql, mids));
    }

    public void doThreadGet(HttpServletRequest request, HttpServletResponse response, int vuid) throws IOException {
        int mid = Utils.parseInt(request.getParameter("mid"), 0);
        com.juick.Message msg = MessagesQueries.getMessage(sql, mid);
        if (msg != null) {
            if (!MessagesQueries.canViewThread(sql, mid, vuid)) {
                response.sendError(403);
            } else {
                List<com.juick.Message> replies = MessagesQueries.getReplies(sql, mid);
                replies.add(0, msg);
                feedMessages(request, response, replies);
            }
        } else {
            response.sendError(404);
        }
    }

    public void doGetRecommended(HttpServletRequest request, 
            HttpServletResponse response, int vuid) 
            throws ServletException, IOException {
        int before_mid = Utils.parseInt(request.getParameter("before_mid"), 0);

        List<Integer> mids = MessagesQueries.getUserRecommendations(sql, vuid, before_mid);
        if (mids != null && !mids.isEmpty()) {
            List<com.juick.Message> msgs = MessagesQueries.getMessages(sql, mids);
            if (msgs != null && !msgs.isEmpty()) {
                String json = messageSerializer.serializeList(msgs);
                Main.replyJSON(request, response, json);
            } else {
                response.sendError(404);
            }
        } else {
            response.sendError(404);
        }
    }

    public void doSetPrivacy(HttpServletRequest request, 
            HttpServletResponse response, Stream xmpp, int vuid) 
            throws ServletException, IOException {
        int mid = Utils.parseInt(request.getParameter("mid"), 0);
        com.juick.User user = MessagesQueries.getMessageAuthor(sql, mid);
        if (user != null && user.getUID() == vuid && MessagesQueries.setMessagePrivacy(sql, mid)) {
            Main.replyJSON(request, response, "{\"status\":\"ok\"}");
        } else {
            response.sendError(400);
        }
    }

    public void doSetPopular(HttpServletRequest request, 
            HttpServletResponse response, Stream xmpp) 
            throws ServletException, IOException {
        int mid = Utils.parseInt(request.getParameter("mid"), 0);
        int popular = Utils.parseInt(request.getParameter("popular"), 0);

        if (mid > 0) {
            boolean ret = MessagesQueries.setMessagePopular(sql, mid, popular);

            if (ret && popular == 2) {
                try {
                    com.juick.Message m = MessagesQueries.getMessage(sql, mid);
                    if (m != null) {
                        Message msg = new Message();
                        msg.from = new JID("juick", "juick.com", null);
                        msg.to = new JID(null, "crosspost.juick.com", null);
                        JuickMessage jmsg = new JuickMessage(m);
                        jmsg.setUser(UserQueries.getUserByUID(sql, 11574).get());
                        msg.childs.add(jmsg);

                        msg.to.Username = "twitter";
                        xmpp.send(msg);
                        msg.to.Username = "fb";
                        xmpp.send(msg);
                        msg.to.Username = "vk";
                        xmpp.send(msg);
                    } else {
                        throw new Exception("Message not found");
                    }
                } catch (Exception e) {
                    logger.log(Level.SEVERE, "SETPOPULAR ERROR", e);
                }
            }

            Main.replyJSON(request, response, "{\"status\":\"ok\"}");
        }
    }
}