/*
 * Copyright (C) 2008-2017, Juick
 *
 * 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.api;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.juick.service.MessagesService;
import com.juick.service.SubscriptionService;
import com.juick.service.TelegramService;
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 org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.PingMessage;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.io.IOException;
import java.util.List;

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

/**
 * Created by vt on 12/05/16.
 */
@Component
public class TelegramBotManager extends TextWebSocketHandler {
    private static final Logger logger = LoggerFactory.getLogger(TelegramBotManager.class);

    private TelegramBot bot;

    @Value("${telegram_token}")
    private String telegramToken;
    @Inject
    private TelegramService telegramService;
    @Inject
    private MessagesService messagesService;
    @Inject
    private SubscriptionService subscriptionService;
    @Inject
    private ObjectMapper jsonMapper;

    private WebSocketSession session;

    @PostConstruct
    public void init() {
        if (StringUtils.isBlank(telegramToken)) {
            logger.info("telegram token is not set, exiting");
            return;
        }
        bot = TelegramBotAdapter.build(telegramToken);
        try {
            SetWebhook webhook = new SetWebhook().url("https://api.juick.com/tlgmbtwbhk");
            if (!bot.execute(webhook).isOk()) {
                logger.error("error setting webhook");
            }
        } catch (Exception e) {
            logger.warn("couldn't initialize telegram bot", e);
        }
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        logger.info("WebSocket connected");
        this.session = session;
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        logger.info("WebSocket disconnected with code {}: {}", status.getCode(), status.getReason());
    }

    @Scheduled(fixedRate = 30000)
    public void ping() throws IOException {
        if (session != null) {
            logger.debug("Sending WebSocket ping");
            session.sendMessage(new PingMessage());
        }
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage text) throws Exception {
        com.juick.Message jmsg = jsonMapper.readValue(text.asBytes(), com.juick.Message.class);

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

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

            List<Long> users = telegramService.getTelegramIdentifiers(subscriptionService.getSubscribedUsers(jmsg.getUser().getUid(), jmsg.getMid()));
            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.getTelegramIdentifiers(
                    subscriptionService.getUsersSubscribedToComments(jmsg.getMid(), jmsg.getUser().getUid())
            ).forEach(c -> telegramNotify(c, fmsg, msgUrl));
        }
    }

    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 get your subscriptions and ability to post messages").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);
            }
        });
    }

    public TelegramBot getBot() {
        return bot;
    }
}