package com.juick.api.controllers;

import com.juick.Tag;
import com.juick.User;
import com.juick.api.ApiServer;
import com.juick.api.util.HttpBadRequestException;
import com.juick.api.util.HttpForbiddenException;
import com.juick.api.util.HttpNotFoundException;
import com.juick.server.helpers.Status;
import com.juick.service.MessagesService;
import com.juick.service.TagService;
import com.juick.service.UserService;
import org.apache.commons.lang3.math.NumberUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import rocks.xmpp.addr.Jid;
import rocks.xmpp.core.stanza.model.Message;

import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * @author ugnich
 */
@Controller
@ResponseBody
public class Messages {
    private static final Logger logger = LoggerFactory.getLogger(Messages.class);

    @Inject
    private MessagesService messagesService;
    @Inject
    private UserService userService;
    @Inject
    private TagService tagService;
    @Inject
    ApiServer apiServer;

    // TODO: serialize image urls

    @RequestMapping(value = "/home", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public List<com.juick.Message> doGetHome(HttpServletRequest request) {
        // TODO: use spring-security
        String auth = request.getHeader("Authorization");
        int vuid = userService.getUIDByHttpAuth(auth);
        if (vuid == -1) {
            throw new HttpForbiddenException();
        }
        if (vuid == 0) {
            String hash = request.getParameter("hash");
            if (hash != null && hash.length() == 16) {
                vuid  = userService.getUIDbyHash(hash);
            }
        }
        if (vuid == 0) {
            throw new HttpForbiddenException();
        }
        int before_mid = NumberUtils.toInt(request.getParameter("before_mid"), 0);
        List<Integer> mids = messagesService.getMyFeed(vuid, before_mid);
        return messagesService.getMessages(mids);
    }

    @RequestMapping(value = "/messages", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public List<com.juick.Message> doGet(HttpServletRequest request) {
        // TODO: use spring-security
        String auth = request.getHeader("Authorization");
        int vuid = userService.getUIDByHttpAuth(auth);
        if (vuid == -1) {
            throw new HttpForbiddenException();
        }
        if (vuid == 0) {
            String hash = request.getParameter("hash");
            if (hash != null && hash.length() == 16) {
                vuid  = userService.getUIDbyHash(hash);
            }
        }
        int before_mid = NumberUtils.toInt(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;
        if (!StringUtils.isEmpty(uname)) {
            User user = userService.getUserByName(uname);
            if (user != null) {
                if (!StringUtils.isEmpty(media)) {
                    mids = messagesService.getUserPhotos(user.getUid(), 0, before_mid);
                } else if (!StringUtils.isEmpty(tag)) {
                    Tag tagObject = tagService.getTag(tag, false);
                    if (tagObject != null) {
                        mids = messagesService.getUserTag(user.getUid(), tagObject.TID, 0, before_mid);
                    } else {
                        throw new HttpNotFoundException();
                    }
                } else {
                    mids = messagesService.getUserBlog(user.getUid(), 0, before_mid);
                }
            } else {
                throw new HttpNotFoundException();
            }
        } else {
            if (!StringUtils.isEmpty(popular)) {
                mids = messagesService.getPopular(vuid, before_mid);
            } else if (!StringUtils.isEmpty(media)) {
                mids = messagesService.getPhotos(vuid, before_mid);
            } else if (!StringUtils.isEmpty(tag)) {
                Tag tagObject = tagService.getTag(tag, false);
                if (tagObject != null) {
                    mids = messagesService.getTag(tagObject.TID, vuid, before_mid, 20);
                } else {
                    throw new HttpNotFoundException();
                }
            } else {
                mids = messagesService.getAll(vuid, before_mid);
            }
        }
        return messagesService.getMessages(mids);
    }

    @RequestMapping(value = "/thread", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public List<com.juick.Message> doThreadGet(HttpServletRequest request) {
        // TODO: use spring-security
        String auth = request.getHeader("Authorization");
        int vuid = userService.getUIDByHttpAuth(auth);
        if (vuid == -1) {
            throw new HttpForbiddenException();
        }
        if (vuid == 0) {
            String hash = request.getParameter("hash");
            if (hash != null && hash.length() == 16) {
                vuid  = userService.getUIDbyHash(hash);
            }
        }
        int mid = NumberUtils.toInt(request.getParameter("mid"), 0);
        com.juick.Message msg = messagesService.getMessage(mid);
        if (msg != null) {
            if (!messagesService.canViewThread(mid, vuid)) {
                throw new HttpForbiddenException();
            } else {
                List<com.juick.Message> replies = messagesService.getReplies(mid);
                replies.add(0, msg);
                return replies;
            }
        }
        throw new HttpNotFoundException();
    }

    @RequestMapping(value = "/messages/recommended", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public List<com.juick.Message> doGetRecommended(HttpServletRequest request) {
        // TODO: use spring-security
        String auth = request.getHeader("Authorization");
        int vuid = userService.getUIDByHttpAuth(auth);
        if (vuid == -1) {
            throw new HttpForbiddenException();
        }
        if (vuid == 0) {
            String hash = request.getParameter("hash");
            if (hash != null && hash.length() == 16) {
                vuid  = userService.getUIDbyHash(hash);
            }
        }
        if (vuid == 0) {
            throw new HttpForbiddenException();
        }
        int before_mid = NumberUtils.toInt(request.getParameter("before_mid"), 0);

        List<Integer> mids = messagesService.getUserRecommendations(vuid, before_mid);
        if (mids != null && !mids.isEmpty()) {
            List<com.juick.Message> msgs = messagesService.getMessages(mids);
            if (msgs != null && !msgs.isEmpty()) {
                return msgs;
            } else {
                throw new HttpForbiddenException();
            }
        }
        throw new HttpNotFoundException();
    }

    @RequestMapping(value = "/messages/set_privacy", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    public Status doSetPrivacy(HttpServletRequest request) {
        // TODO: use spring-security
        String auth = request.getHeader("Authorization");
        int vuid = userService.getUIDByHttpAuth(auth);
        if (vuid == -1) {
            throw new HttpForbiddenException();
        }
        if (vuid == 0) {
            String hash = request.getParameter("hash");
            if (hash != null && hash.length() == 16) {
                vuid  = userService.getUIDbyHash(hash);
            }
        }
        if (vuid == 0) {
            throw new HttpForbiddenException();
        }
        int mid = NumberUtils.toInt(request.getParameter("mid"), 0);
        com.juick.User user = messagesService.getMessageAuthor(mid);
        if (user != null && user.getUid() == vuid && messagesService.setMessagePrivacy(mid)) {
            return new Status("ok");
        } else {
            throw new HttpBadRequestException();
        }
    }

    @RequestMapping(value = "/messages/set_popular", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public Status doSetPopular(HttpServletRequest request) {
        int mid = NumberUtils.toInt(request.getParameter("mid"), 0);
        int popular = NumberUtils.toInt(request.getParameter("popular"), 0);

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

            if (ret && popular == 2) {
                try {
                    com.juick.Message m = messagesService.getMessage(mid);
                    if (m != null) {
                        Message msg = new Message();
                        msg.setFrom(Jid.of("juick@juick.com"));
                        msg.setTo(Jid.of("crosspost.juick.com"));
                        m.setUser(userService.getUserByUID(11574).get());
                        msg.addExtension(m);

                        msg.setTo(Jid.of("twitter@crosspost.juick.com"));
                        apiServer.getXmpp().send(msg);
                        msg.setTo(Jid.of("fb@crosspost.juick.com"));
                        apiServer.getXmpp().send(msg);
                        msg.setTo(Jid.of("vk@crosspost.juick.com"));
                        apiServer.getXmpp().send(msg);
                    } else {
                        throw new Exception("Message not found");
                    }
                } catch (Exception e) {
                    logger.error("SETPOPULAR ERROR", e);
                }
            }
            return new Status("ok");
        }
        throw new HttpBadRequestException();
    }
}