package me.James.commands.xpGains;

import com.vdurmont.emoji.EmojiParser;
import me.James.modules.Modules;
import me.James.userMess.UserMess;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.user.User;
import org.javacord.api.event.message.reaction.ReactionAddEvent;
import org.javacord.api.listener.message.MessageCreateListener;
import org.javacord.api.listener.message.reaction.ReactionAddListener;
import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class ConnectFour implements Experienceable {
    private final static int WINNING_XP = 25;
    private final static ConnectFourPiece STARTING_USER_PIECE = ConnectFourPiece.BLUE;
    private final static ConnectFourPiece SECOND_USER_PIECE = ConnectFourPiece.RED;
    private long winningUser = 0;
    private static ConnectFourPiece[][] canvas = new ConnectFourPiece[7][6];
    private long startingUser;
    private long secondUser = 0;
    private Semaphore lock = new Semaphore(1);
    private long currentUser;
    private Modules mods;
    private DiscordApi api;
    public ConnectFour(DiscordApi api, UserMess mess) {
        this.api = api;
        this.mods = new Modules(api);
        startingUser = mess.getMessageAuthor().getId();
        currentUser = mess.getMessageAuthor().getId();
        initializeBoard();
        post(mess);
        new ExperienceHandler(this);
    }

    private void initializeBoard() {
        ConnectFourPiece[][] canvas = new ConnectFourPiece[6][7];
        for (int y = 0; y < 6; y++) {
            for (int x = 0; x < 7; x++) {
                canvas[y][x] = ConnectFourPiece.EMPTY;
            }
        }
    }

    private void post(UserMess mess) {
        mess.sendMessage(mods.successEmbedGen("Should this be a :one: closed game, or :two: open game?", mess)).thenAccept(gameJoinState ->
                gameJoinState.addReactions(EmojiParser.parseToUnicode(":one:"), EmojiParser.parseToUnicode(":two:")).thenAccept(aVoid -> {
                    gameJoinState.addReactionAddListener(event -> {
                        if(event.getUser().getId() == startingUser){
                            getSecondUser(event, mess)
                                    .thenAccept(aVoid1 -> playLoop()).exceptionally(exception -> {
                                        if(exception instanceof ForcefulGameEnd)
                                            mess.sendMessage(mods.successEmbedGen("Canceling game!", mess))
                                                    .thenAccept(gameEndMessage -> api
                                                            .getThreadPool()
                                                            .getScheduler()
                                                            .schedule((Runnable) gameEndMessage::delete, 20, TimeUnit.SECONDS));
                                        else if (exception instanceof InvalidGameStart){
                                            mess.sendMessage(mods.successEmbedGen("Something went wrong getting a second user! Cancelling game!", mess))
                                                    .thenAccept(gameEndMessage -> api
                                                            .getThreadPool()
                                                            .getScheduler()
                                                            .schedule((Runnable) gameEndMessage::delete, 20, TimeUnit.SECONDS));
                                        }
                                        gameJoinState.getReactionAddListeners().forEach(reactionAddListener -> gameJoinState.removeListener(ReactionAddListener.class, reactionAddListener));
                                        mess.sendMessage(exception.getMessage());
                                        return null;
                            });
                        }
                    });
                })
        );
    }
    private void playLoop() {
        List<Long> players = new LinkedList<>();
        players.add(startingUser);
        players.add(secondUser);
        Iterator<Long> playerIterable = players.iterator();
        while (playerIterable.hasNext()) try {
            lock.acquire();
            final long currentPlayer = playerIterable.next();
            Point placed = playTurn(currentPlayer);
            if (cheackForWin(placed, currentPlayer == startingUser ? ConnectFourPiece.RED : ConnectFourPiece.BLUE))
                endGame();
        } catch (InterruptedException e) {
            throw new InvalidGameStart();
        }
    }
    private Point playTurn(long player) {
        return new Point(2,2);
    }
    private void endGame() {

    }
    private CompletableFuture<Void> getSecondUser(ReactionAddEvent event, UserMess mess) {
        return CompletableFuture.supplyAsync(() -> {
            if (event.getEmoji().asUnicodeEmoji().map(":one:"::equals).orElse(false)) {
                api.getCachedUserById(startingUser).ifPresent(user ->
                        mess.sendMessage(mods.successEmbedGen("Mention someone to invite them to this game! You can always use `exit to quit to quit the game.", mess)).thenAccept(getSecondPlayerMessage ->
                                user.addMessageCreateListener(secondPlayerEvent -> {
                                    if(secondPlayerEvent.getMessage().getContent().startsWith("`exit")) throw new InvalidGameStart();
                                    if (!secondPlayerEvent.getMessage().getMentionedUsers().isEmpty()) {
                                        mess.sendMessage(mods.successEmbedGen(
                                                String.format(
                                                        "%s has invited you, %s, to a game of Connect Four, do you accept?",
                                                        api.getCachedUserById(startingUser).map(User::getMentionTag).orElse("Error getting Name"),
                                                        secondPlayerEvent.getMessage().getMentionedUsers().get(0).getMentionTag()
                                                ), mess)).thenAccept(secondPlayerInviteMessage ->
                                                secondPlayerInviteMessage.addReactions(EmojiParser.parseToUnicode(":check:"), EmojiParser.parseToUnicode(":xmark:")).thenAccept(secondPlayerAccept -> {
                                                    secondPlayerInviteMessage.addReactionAddListener(secondPlayerAcceptReaction -> {
                                                        if (secondPlayerAcceptReaction.getUser().getId() == secondPlayerEvent.getMessage().getMentionedUsers().get(0).getId() && secondPlayerAcceptReaction.getEmoji().asUnicodeEmoji().map(":check:"::equals).orElse(false)) {
                                                            secondUser = secondPlayerAcceptReaction.getUser().getId();
                                                            secondPlayerInviteMessage.getReactionAddListeners().forEach(reactionAddListener -> secondPlayerInviteMessage.removeListener(ReactionAddListener.class, reactionAddListener));
                                                            return;
                                                        } else if (secondPlayerAcceptReaction.getEmoji().asUnicodeEmoji().map(":xmark"::equals).orElse(false)) {
                                                            secondPlayerInviteMessage.getReactionAddListeners().forEach(reactionAddListener -> secondPlayerInviteMessage.removeListener(ReactionAddListener.class, reactionAddListener));
                                                            user.getMessageCreateListeners().forEach(messageCreateListener -> user.removeListener(MessageCreateListener.class, messageCreateListener));
                                                            throw new ForcefulGameEnd();
                                                        }
                                                    });
                                                })
                                        );
                                    }
                                })
                        ));
            }
            throw new InvalidGameStart();
        });
    }
    private static String drawBoard() {
        StringBuilder canvasStringRepresentation = new StringBuilder();
        for(int y = 0; y < canvas.length; y++) {
            for(int x = canvas[0].length - 1; x > 0; x--) {
                canvasStringRepresentation.append(String.format("%s ", canvas[x][y].getDiscordRepresentation()));
            }
            canvasStringRepresentation.append("\n");
        }
        return canvasStringRepresentation.toString();
    }

    private static void updateBoard(int column, ConnectFourPiece currentPiece) {
        for(int y = 0; y < canvas[0].length; y++){
            if (!(canvas[y][column] == ConnectFourPiece.EMPTY)) {
                canvas[y][column] = currentPiece;
                break;
            }
        }
    }
    private boolean isNear(Point pos, Point pos1) {
        return ((pos1.x + 1 == pos.x || pos1.x == pos.x || pos1.x - 1 == pos.x) &&
                (pos1.y + 1 == pos.y || pos1.y == pos.y || pos1.y - 1 == pos1.y) &&
                !((pos1.x + 1 == pos.x || pos1.x - 1 == pos.x) &&
                        (pos1.y + 1 == pos.y || pos1.y - 1 == pos.y)));
    }
    private boolean patternSearcher(HashMap<Integer, Point> connectedHashMap) {
        boolean won = false;
        for (Map.Entry<Integer, Point> entry : connectedHashMap.entrySet()) {
            Integer integer = entry.getKey();
            Point point = entry.getValue();

        }
        return won;
    }
    private boolean cheackForWin(final Point origin, final ConnectFourPiece piece) {
        HashMap<Integer, Point> connectedHashMap = new HashMap<>();
        for (int col = 0; col < canvas.length; col++) {
            for (int row = 0; row < canvas[0].length; row++) {
                if (canvas[col][row].equals(piece) && isNear(origin, new Point(col, row))) {
                    if (connectedHashMap.size() < 4)
                        connectedHashMap.put(connectedHashMap.size() + 1, new Point(col, row));
                    else return patternSearcher(connectedHashMap);
                }
            }
        }
        return false;
    }

    @Override
    public Map.Entry<Long, Integer> gainXp() {
        return new AbstractMap.SimpleImmutableEntry<>(winningUser, WINNING_XP);
    }

    @Override
    public String gameName() {
        return "Connect Four";
    }
    enum ConnectFourPiece {
        RED(EmojiParser.parseToUnicode(":red_circle:")),
        BLUE(EmojiParser.parseToUnicode(":large_blue_circle:")),
        EMPTY(EmojiParser.parseToUnicode(":black_circle:"));
        private String discordRepresentation;
        ConnectFourPiece(String discordRepresentation){
            this.discordRepresentation = discordRepresentation;
        }
        public String getDiscordRepresentation() {
            return discordRepresentation;
        }
    }
    class ForcefulGameEnd extends RuntimeException {
        ForcefulGameEnd() {
            super("Starting user ended the game");
        }
    }
    class InvalidGameStart extends RuntimeException {
        InvalidGameStart() {
            super("Something went wrong while finding the second user!");
        }
    }
}