/*
 * 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.controllers;

import com.juick.User;
import com.juick.api.ApiServer;
import com.juick.api.TelegramBotManager;
import com.juick.server.util.HttpUtils;
import com.juick.service.TelegramService;
import com.juick.service.UserService;
import com.pengrad.telegrambot.BotUtils;
import com.pengrad.telegrambot.model.Message;
import com.pengrad.telegrambot.model.MessageEntity;
import com.pengrad.telegrambot.model.PhotoSize;
import com.pengrad.telegrambot.model.Update;
import com.pengrad.telegrambot.request.GetFile;
import com.pengrad.telegrambot.response.GetFileResponse;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;
import springfox.documentation.annotations.ApiIgnore;

import javax.inject.Inject;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

/**
 * Created by vt on 24/11/2016.
 */
@ApiIgnore
@RestController
public class TelegramWebhook {
    private static Logger logger = LoggerFactory.getLogger(TelegramWebhook.class);
    @Inject
    private UserService usersService;
    @Inject
    private TelegramService telegramService;
    @Inject
    private TelegramBotManager telegramBotManager;
    @Inject
    private ApiServer apiServer;
    @Value("${upload_tmp_dir:/var/www/juick.com/i/tmp/}")
    private String tmpDir;


    @RequestMapping(value = "/tlgmbtwbhk", method = RequestMethod.POST)
    @ResponseStatus(value = HttpStatus.OK)
    public void processUpdate(InputStream body) throws Exception {
        String data = IOUtils.toString(body, StandardCharsets.UTF_8);
        logger.info("got telegram msg: {}", data);
        Update update = BotUtils.parseUpdate(data);
        Message message = update.message();
        if (update.message() == null) {
            message = update.editedMessage();
            if (message == null) {
                logger.error("error parsing telegram update: {}", update);
                return;
            }
        }
        User user_from = usersService.getUserByUID(telegramService.getUser(message.chat().id())).orElse(new User());
        logger.info("Found juick user {}", user_from.getUid());

        List<Long> chats = telegramService.getChats();
        String username = message.from().username();
        if (username == null) {
            username = message.from().firstName();
        }
        if (!chats.contains(message.chat().id())) {
            telegramService.addChat(message.chat().id());
            logger.info("added chat with {}", username);
            telegramService.createTelegramUser(message.from().id(), username);
            telegramBotManager.telegramSignupNotify(message.from().id().longValue(), usersService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
        } else {
            if (user_from.getUid() == 0) {
                telegramBotManager.telegramSignupNotify(message.from().id().longValue(), usersService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
            } else {
                String attachment = StringUtils.EMPTY;
                if (message.photo() != null) {
                    String fileId = Arrays.stream(message.photo()).max(Comparator.comparingInt(PhotoSize::fileSize))
                            .orElse(new PhotoSize()).fileId();
                    if (StringUtils.isNotEmpty(fileId)) {
                        GetFile request = new GetFile(fileId);
                        GetFileResponse response = telegramBotManager.getBot().execute(request);
                        logger.info("got file {}", response.file());
                        URL fileURL = new URL(telegramBotManager.getBot().getFullFilePath(response.file()));
                        attachment = HttpUtils.downloadImage(fileURL, tmpDir);
                        logger.info("received {}", attachment);
                    }
                }
                String text = message.text();
                if (StringUtils.isBlank(text)) {
                    text = message.caption();
                }
                if (StringUtils.isNotEmpty(text)) {
                    if (text.equalsIgnoreCase("/login")) {
                        String msgUrl = "http://juick.com/login?" + usersService.getHashByUID(user_from.getUid());
                        String msg = String.format("Hi, %s!\nTap to [log in](%s)", user_from.getName(), msgUrl);
                        telegramBotManager.telegramNotify(message.from().id().longValue(), msg);
                    } else {
                        Message replyMessage = message.replyToMessage();
                        if (replyMessage != null) {
                            Optional<MessageEntity> juickLink = Arrays.stream(replyMessage.entities())
                                    .filter(this::isJuickLink)
                                    .findFirst();
                            if (juickLink.isPresent()) {
                                if (StringUtils.isNotEmpty(juickLink.get().url())) {
                                    UriComponents uriComponents = UriComponentsBuilder.fromUriString(
                                            juickLink.get().url()).build();
                                    String path = uriComponents.getPath();
                                    if (StringUtils.isNotEmpty(path) && path.length() > 1) {
                                        int mid = Integer.valueOf(path.substring(1));
                                        String prefix = String.format("#%d ", mid);
                                        if (StringUtils.isNotEmpty(uriComponents.getFragment())) {
                                            int rid = Integer.valueOf(uriComponents.getFragment());
                                            prefix = String.format("#%d/%d ", mid, rid);
                                        }
                                        apiServer.processMessage(user_from, prefix + text, attachment);
                                        telegramBotManager.telegramNotify(message.from().id().longValue(), "Reply sent");
                                    } else {
                                        logger.warn("invalid path: {}", path);
                                    }
                                } else {
                                    logger.warn("invalid entity: {}", juickLink);
                                }
                            } else {
                                telegramBotManager.telegramNotify(message.from().id().longValue(),
                                        "Can not reply to this message", message.messageId());
                            }
                        } else {
                            apiServer.processMessage(user_from, text, attachment);
                            telegramBotManager.telegramNotify(message.from().id().longValue(), "Message sent");
                        }
                    }
                }
            }
        }
    }
    boolean isJuickLink(MessageEntity e) {
        return e.offset() == 0 && e.type().equals(MessageEntity.Type.text_link) && e.length() == 2;
    }
}