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

/**
 * 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 {
        Update update = BotUtils.parseUpdate(new InputStreamReader(body, StandardCharsets.UTF_8));
        Message message = update.message();
        if (update.message() == null) {
            message = update.editedMessage();
            if (message == null) {
                logger.error("error parsing telegram update: {}", update);
                return;
            }
        }

        logger.info("got telegram msg {}", message);
        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) {
                            String finalText = text;
                            String finalAttachment = attachment;
                            Message finalMessage = message;
                            Arrays.stream(replyMessage.entities())
                                    .filter(e -> e.offset() == 0).findFirst().ifPresent(e -> {
                                    if (StringUtils.isNotEmpty(e.url())) {
                                        UriComponents uriComponents = UriComponentsBuilder.fromUriString(e.url()).build();
                                        int mid = Integer.valueOf(uriComponents.getPath().substring(1));
                                        String prefix = String.format("#%d ", mid);
                                        int rid = 0;
                                        if (StringUtils.isNotEmpty(uriComponents.getFragment())) {
                                            rid = Integer.valueOf(uriComponents.getFragment());
                                            prefix = String.format("#%d/%d ", mid, rid);
                                        }
                                        apiServer.processMessage(user_from, prefix + finalText, finalAttachment);
                                        telegramBotManager.telegramNotify(finalMessage.from().id().longValue(), "reply sent");
                                    }
                            });
                        } else {
                            apiServer.processMessage(user_from, text, attachment);
                            telegramBotManager.telegramNotify(message.from().id().longValue(), "message sent");
                        }
                    }
                }
            }
        }
    }
}