package de.fiftx.discordbot.twitch;

import java.io.BufferedReader;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Formatter;
import java.util.HashSet;
import java.util.Set;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class TwitchServerHandle {

    private static final Logger log = LoggerFactory.getLogger(TwitchServerHandle.class);

    private Server server;
    private TwitchHandle handle;
    private String secret;
    private Set<Integer> ids;

    public TwitchServerHandle(int port, TwitchHandle handle, String secret) {
        this.secret = secret;
        this.handle = handle;
        this.ids = new HashSet<>();

        server = new Server(port);
        server.setHandler(new RequestHandler());

        try {
            server.start();

            log.info("Webhookserver started on port {} using secret {}", port, secret);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        Runtime.getRuntime().addShutdownHook(new Thread(() ->  {
            try {
                server.stop();
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }

            handle.unsubscribeAll();
        }));
    }


    private String createSignature(String secret, String payload) throws InvalidKeyException, NoSuchAlgorithmException {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec signingKey = new SecretKeySpec(secret.getBytes(), "HmacSHA256");

        mac.init(signingKey);
        byte[] raw = mac.doFinal(payload.getBytes());

        StringBuilder sb = new StringBuilder(raw.length * 2);

        Formatter formatter = new Formatter(sb);
        for (byte b : raw) {
            formatter.format("%02x", b);
        }

        formatter.close();

        return sb.toString();
    }


    private class RequestHandler extends AbstractHandler {

        @Override
        public void handle(String target, Request request, HttpServletRequest servRequest, HttpServletResponse response)
                throws IOException, ServletException {
            log.info("Received connection - handling now");

            if(request.getMethod().toUpperCase().equals("GET")) {
                String challenge = request.getParameter("hub.challenge");
                if(challenge != null) {
                    response.setContentType("text/plain");

                    response.getWriter().print(challenge);
                    response.getWriter().flush();

                    response.setStatus(HttpServletResponse.SC_OK);

                    request.setHandled(true);

                    response.flushBuffer();

                    log.info("Confirmed challenge key {}", challenge);
                }
            }

            if(request.getMethod().toUpperCase().equals("POST")) {
                String line = null;
                String content = "";

                BufferedReader reader = request.getReader();

                while((line = reader.readLine()) != null) content += line;

                try {
                    String hash = createSignature(secret, content);
                    if(hash.equals(request.getHeader("X-Hub-Signature"))) {
                        JsonObject object = new JsonParser().parse(content).getAsJsonObject();
                        JsonArray array = object.get("data").getAsJsonArray();
                        if(array.size() > 0) {
                            JsonObject data = array.get(0).getAsJsonObject();

                            TwitchStream stream = new TwitchStream(data.get("id").getAsInt(),
                                    data.get("user_id").getAsInt(),
                                    data.get("game_id").getAsInt(),
                                    data.get("type").getAsString(),
                                    data.get("title").getAsString(),
                                    data.get("viewer_count").getAsInt(),
                                    data.get("started_at").getAsString(),
                                    data.get("language").getAsString(),
                                    data.get("thumbnail_url").getAsString());

                            log.info("Received online stream {} by {} / hash {}", stream.getId(), stream.getUser(), hash);

                            if(!ids.contains(stream.getId())) {
                                handle.send(stream);
                                log.info("Send online stream {}", stream.getId());
                            }

                            ids.add(stream.getId());

                        }

                        response.setStatus(HttpServletResponse.SC_OK);
                    } else {
                        log.info("Hash not correct, got {} against {}", hash, request.getHeader("X-Hub-Signature"));
                    }
                } catch (InvalidKeyException | NoSuchAlgorithmException e) {
                    log.error(e.getMessage(), e);
                }
            }

            request.setHandled(true);
        }
    }

    public void close() {
        try {
            server.stop();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}