package com.juick.api;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.juick.service.MessagesService;
import com.juick.service.TelegramService;
import com.neovisionaries.ws.client.WebSocket;
import com.neovisionaries.ws.client.WebSocketAdapter;
import com.neovisionaries.ws.client.WebSocketFactory;
import com.neovisionaries.ws.client.WebSocketFrame;
import com.pengrad.telegrambot.Callback;
import com.pengrad.telegrambot.TelegramBot;
import com.pengrad.telegrambot.TelegramBotAdapter;
import com.pengrad.telegrambot.model.request.InlineKeyboardButton;
import com.pengrad.telegrambot.model.request.InlineKeyboardMarkup;
import com.pengrad.telegrambot.request.SendMessage;
import com.pengrad.telegrambot.request.SetWebhook;
import com.pengrad.telegrambot.response.SendResponse;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.inject.Inject;
import java.io.IOException;
import java.util.List;
import java.util.Map;

import static com.juick.formatters.PlainTextFormatter.formatPost;
import static com.juick.formatters.PlainTextFormatter.formatUrl;

/**
 * Created by vt on 12/05/16.
 */
public class TGBot implements AutoCloseable {
    private static final Logger logger = LoggerFactory.getLogger(TGBot.class);

    TelegramBot bot;
    WebSocket ws;
    private ObjectMapper ms;

    @Inject
    TelegramService telegramService;
    @Inject
    MessagesService messagesService;

    private TGBot() {
        throw new IllegalStateException();
    }

    public TGBot(String token) {
        if (StringUtils.isBlank(token)) {
            return;
        }
        bot = TelegramBotAdapter.build(token);
        ms = new ObjectMapper();
        ms.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
        ms.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        ms.setSerializationInclusion(JsonInclude.Include.NON_DEFAULT);
        try {
            SetWebhook webhook = new SetWebhook().url("https://api.juick.com/tlgmbtwbhk");
            if (!bot.execute(webhook).isOk()) {
                logger.error("error setting webhook");
            }
            ws = new WebSocketFactory().createSocket("wss://ws.juick.com/");
            ws.setPingInterval(60 * 1000);
            ws.addListener(new WebSocketAdapter() {
                @Override
                public void onDisconnected(WebSocket websocket, WebSocketFrame serverCloseFrame, WebSocketFrame clientCloseFrame, boolean closedByServer) throws Exception {
                    logger.info("ws disconnected");
                    ws.recreate();
                }

                @Override
                public void onConnected(WebSocket websocket, Map<String, List<String>> headers) {
                    logger.info("ws connected");
                }

                @Override
                public void onTextMessage(WebSocket websocket, String text) throws Exception {
                    super.onTextMessage(websocket, text);
                    com.juick.Message jmsg = ms.readValue(text, com.juick.Message.class);

                    if (logger.isInfoEnabled()) // prevent writeValueAsString execution if logger disabled
                        logger.info("got jmsg: {}", ms.writeValueAsString(jmsg));

                    String msgUrl = formatUrl(jmsg);
                    if (jmsg.getRid() == 0) {
                        String msg = formatPost(jmsg);

                        List<Long> users = telegramService.getSubscribers(jmsg.getUser().getUid());
                        List<Long> chats = telegramService.getChats();
                        // registered subscribed users

                        users.forEach(c -> telegramNotify(c, msg, msgUrl));
                        // anonymous
                        chats.stream().filter(u -> telegramService.getUser(u) == 0).forEach(c -> telegramNotify(c, msg, msgUrl));
                    } else {
                        // get quote
                        com.juick.Message msg = messagesService.getReply(jmsg.getMid(), jmsg.getRid());
                        String fmsg = formatPost(msg);
                        telegramService.getSubscribersToComments(jmsg.getMid(), jmsg.getUser().getUid()).forEach(c -> telegramNotify(c, fmsg, msgUrl));
                    }
                }
            });
            ws.connect();
        } catch (Exception e) {
            logger.warn("couldn't initialize telegram bot", e);
        }
    }

    public void telegramNotify(Long c, String msg, String msgUrl) {
        SendMessage telegramMessage = new SendMessage(c, msg);
        if (msgUrl != null) {
            telegramMessage.replyMarkup(
                    new InlineKeyboardMarkup(
                            new InlineKeyboardButton[]{
                                    new InlineKeyboardButton("See on Juick").url(msgUrl)
                            }
                    ));
        }
        bot.execute(telegramMessage, new Callback<SendMessage, SendResponse>() {
            @Override
            public void onResponse(SendMessage request, SendResponse response) {
                logger.info("got response: {}", response.message());
            }

            @Override
            public void onFailure(SendMessage request, IOException e) {
                logger.warn("telegram failure", e);
            }
        });
    }

    public void telegramSignupNotify(Long telegramId, String hash) {
        bot.execute(new SendMessage(telegramId,
                "You are subscribed to all Juick messages. " +
                        "Create or link an existing Juick account to control " +
                        "what do you want to receive").replyMarkup(
                new InlineKeyboardMarkup(
                        new InlineKeyboardButton[]{
                                new InlineKeyboardButton("SIGNUP").url("http://juick.com/signup?type=durov&hash=" +
                                        hash)
                        })), new Callback<SendMessage, SendResponse>() {
            @Override
            public void onResponse(SendMessage request, SendResponse response) {
                logger.info("got response: {}", response.message());
            }

            @Override
            public void onFailure(SendMessage request, IOException e) {
                logger.warn("telegram failure", e);
            }
        });
    }

    @Override
    public void close() throws Exception {
        try {
            if (ws != null) {
                ws.disconnect();
            }
        } catch (Exception e) {
            logger.warn("websocket disconnection exception", e);
        }
    }
}