package AoSBot;

import java.util.*;
import org.jibble.pircbot.*;

public class MyBot extends PircBot {
    /*
    public String name;
    public String time;
    public String address;
    public String players;
    public Boolean on = false;
     */
        private HashMap<String,String> triggers = new HashMap<String,String>();
        private HashMap<String,String> muted = new HashMap<String,String>();
        private HashMap<String,String> users = new HashMap<String,String>();
        private Set<String> mutedKeys = new HashSet<String>(muted.keySet());
        private Set<String> triggersKeys = new HashSet<String>(triggers.keySet());
        private String msgsaftermute = "2";
        private String currentUSERHOST = "";
        boolean finished = false;
        //private boolean awaitingServerResponse = true;
        private String channel = "#AoS";

    public MyBot(){
        this.setName("AoS-MuteBot");
        this.setAutoNickChange(true);
    }
/*
    public void add(String name){
        this.players = this.players+", " + name;
    }

    public String show(){
    return name + " at " + time + " server: " + address;
    }
*/
    @Override
    public void onJoin(String channel, String sender, String login, String hostname){
        /*if(!(users.containsKey(hostname))){
            users.put(hostname, sender);
        } else {

        }*/
        /*String result;
        User users[] = getUsers(channel);
        for(int i=0; i<users.length; i++){
            if(users[i].getNick().equals(sender)){
                users[i].getHost();
            }
        }*/
        //sendMessage(channel, "Hostname: "+hostname);
        currentUSERHOST = "";
        System.out.println("current"+currentUSERHOST);
        sendRawLine("userhost "+sender);
        System.out.println("current"+currentUSERHOST);
        System.out.println("SENT RAW LINE");
        System.out.println("current"+currentUSERHOST);
        while(!finished){ /* wait */}
        System.out.println("FINISHED WAITING");
        currentUSERHOST = "";
        System.out.println("current"+currentUSERHOST);

        System.out.println("RESET");


        //Check if person joined is muted, and if so, issue a warning
        for (String key: muted.keySet()) {
            if(sender.toUpperCase().equals(key)){
                sendNotice(sender, "You are muted on this channel.");
            }
        }
    }
    @Override
    public void onServerResponse(int code, String response){
        if(response.lastIndexOf("@") != -1){
            //presume a userhost
            System.out.println("Response: "+response);
            currentUSERHOST = response;
            finished = true;
        }
    }

    public String getHost(String nickname){
        String result = "";
        System.out.println("current: "+currentUSERHOST);
        System.out.println("SENT RAW LINE (getHost)");
        sendRawLine("userhost "+nickname);

        int i = 0;
        while(currentUSERHOST.equals("")){ i++; System.out.println(i); }
        System.out.println("FINISHED WAITING (getHost)");
        String temp[] = currentUSERHOST.split("@");
        if(temp.length == 2) {
            result = temp[1];
        }
        System.out.println("temp1: "+temp[1]);
        currentUSERHOST = "";
        System.out.println("RESET (getHost)");
        return result;
    }

    @Override
    public void onNickChange(String oldNick, String login, String hostname, String newNick){
        //Check if person joined is muted, and if so, issue a warning
        for (String key: muted.keySet()) {
            if(oldNick.toUpperCase().equals(key)){
                addToMuted(newNick.toUpperCase(), "1");
                sendNotice(newNick, "For changing names you cannot speak again without a kick.");
            }
        }
    }

    @Override
    public void onPrivateMessage(String sender, String login, String hostname, String message){
        if(isOperator(channel, getUserIndex(sender, channel))){
            //msg bot <command> <trigger> <(line)>

            //Addtrig command, should have 3 parts
            if(message.startsWith("addtrigger") || message.startsWith("addtrig")){
                String temp[] = message.split(" ", 3);
                if (temp.length == 3){
                    String trig = temp[1];
                    String msg = temp[2];

                    String currenttrig = triggers.get(trig);
                    if(currenttrig == null){
                        //there is no trigger set under this name
                        addToTriggers(trig, msg);
                        sendNotice(sender, "Added the trigger \""+trig+"\" -> "+msg);
                    } else {
                        //there is a trigger set for this name, so add a \n and add it on
                        String val = currenttrig + "\n" + msg;
                        addToTriggers(trig, val);
                        sendNotice(sender, "Trigger already exists. Added new line to \""+trig+"\":\""+msg);
                    }
                } else {
                    sendNotice(sender, "Improper command, please retry");
                }
            }

            //Modify command
            if(message.startsWith("modifytrigger") || message.startsWith("modtrig")){
                //modtrig !trig edit 1 blah
                String temp[] = message.split(" ");
                if(temp.length == 5){
                    String value = "";
                    for (String key: triggers.keySet()) {
                        if(temp[1].equals(key)){
                            value = triggers.get(key);
                            String linevals[] = value.split("\n");
                            int line = Integer.parseInt(temp[3]);

                            if(temp[2].equals("add")){
                                if(line == 1){
                                    value = temp[4] + "\n" + value;
                                }
                            }
                            if(linevals.length == 2){

                            }
                        }
                    }
                    if(value.equals("")) {
                        sendNotice(sender, "Trigger not found");
                    }
                }else{
                    sendNotice(sender, "Wrong number of parameters: modtrig <trigger> <add/edit/delete> <line number> <msg>");
                }

            }

            //Delete command
            if(message.startsWith("deletetrigger") || message.startsWith("deltrig")){
                //deletetrigger !trigger
                String temp[] = message.split(" ");
                String trig = temp[1];
                String currenttrig = triggers.get(trig);
                if(currenttrig == null){
                    sendNotice(sender, "There is no trigger called \""+trig+"\"..");
                } else {
                    triggers.remove(trig);
                    sendNotice(sender, "Success. \""+trig+"\" has been removed.");
                }
            }

            //change num messages before kicking
            if(message.startsWith("mutelimit")){
                String temp[] = message.split(" ");
                if(temp.length != 2){
                    sendNotice(sender, "Improper command, please retry");
                } else {
                    setMsgsAfterMute(temp[1]);
                    sendNotice(sender, "Success. # of messages before kicking when muted is now "+temp[1]);
                }
            }
        } else {
            sendNotice(sender, "Sorry, you do not have necessary rights to perform said action.");
        }
    }

    @Override
    public void onMessage(String channel, String sender, String login, String hostname, String message) {
        if(message.startsWith("!host")){
            String temp[] = message.split(" ", 2);
            sendMessage(channel, getHost(temp[1]));
        }

        //Checks if the message has a trigger in it
        for (String key: triggers.keySet()) {
            if(message.startsWith(key)){
                System.out.println(triggers.get(key));
                String value = triggers.get(key);
                String temp[] = value.split("\n");

                //for multi-line triggers, cycle through
                for (int i = 0; i<temp.length; i++){
                    sendMessage(channel, temp[i]);
                }
            }
        }

        //testing
        if(message.startsWith("!triggers")){
            sendMessage(channel, "Displaying triggers in console.");
            System.out.println(triggers);
        }
        //Kick command
        if (message.startsWith("!kick")){
            String temp[] = message.split(" ", 3);
            String reason = "Requested by " + sender;
            if(temp.length == 3){
                if(!(temp[2].equals(""))){
                    reason += ", for reason(s):"+temp[2];
                }
            }
            int userindex = getUserIndex(sender, channel);
            if(userindex == -1){
                sendNotice(sender, "Unable to find user "+temp[1]+" on this channel.");
            } else {
                if(isOperator(channel, userindex)){
                    kick(channel, temp[1], reason);
                } else {
                    sendNotice(sender, "Sorry, you do not have necessary rights to perform said action.");
                }
            }
        }

        //Mute command
        if (message.startsWith("!mute")){
            //!mute <username> <reason>
            String temp[] = message.split(" ", 3);
            String reason = "Requested by " + sender;
            if(temp.length == 3){
                if(!(temp[2].equals(""))){
                    reason += ", for reason(s):"+temp[2];
                }
            }
            int userindex = getUserIndex(sender, channel);
            //user index will be returned as -1 if not found, so:
            if(userindex == -1){
                sendNotice(sender, "Unable to find user "+temp[1]+" on this channel.");
            } else {
                if(isOperator(channel, userindex)){
                    sendNotice(temp[1], "You have been muted. "+reason+". This means you are limited in the number of lines you can say before being kicked, so keep quiet.");
                    sendMessage(channel, temp[1]+" has been muted by "+sender);
                    addToMuted(temp[1].toUpperCase(), msgsaftermute);
                } else {
                    sendNotice(sender, "Sorry, you do not have necessary rights to perform said action.");
                }
            }
        }

        //Unmute command
        if (message.startsWith("!unmute")){
            String temp[] = message.split(" ", 3);
            removeFromMuted(temp[1].toUpperCase());
            sendNotice(temp[1], "You have been unmuted on #AoS.");
        }

        //See if user sending message is muted
        checkMuting(hostname, channel, sender);
    }

    public void checkMuting(String host, String channel, String sender){
        System.out.println(mutedKeys);
        int i = 0,j = 0;
        for (String key: muted.keySet()) {
            System.out.println("k: "+i);
            i++;
            System.out.println("Sender: "+sender+"/"+host+", Key: "+key);
            String checksender = sender.toUpperCase();
            if(checksender.equals(key)){
                int left = Integer.parseInt(muted.get(key));
                System.out.println("Left: "+left);
                left--;
                //Decrement amount of lines before kick in the hashmap
                addToMuted(key, Integer.toString(left));
                if(left < 1){
                    //Message & kick
                    sendNotice(sender, "Goodbye, "+sender+".");
                    kick(channel, sender, "For failure to follow the rules and keeping your mouth shut");
                }else{
                    //Warn
                    sendMessage(channel, sender+": "+Integer.toString(left)+" left.");
                    sendNotice(sender, "You have been muted. If you do not stop talking, you shall be kicked after "+left+" line(s)");
                }
            }
        }
    }

    boolean isOperator(String channel, int userindex){
        User users[] = getUsers(channel);
        if(users[userindex].isOp()){
            return true;
        }
        return false;
    }
    boolean isVoiced(String user, String channel){
        User users[] = getUsers(channel);
        if(users[getUserIndex(user, channel)].hasVoice()){
            return true;
        }
        return false;
    }
    int getUserIndex(String user, String channel){
        int result = -1;
        User users[] = getUsers(channel);
        for(int i=0; i<users.length; i++){
            if(users[i].getNick().equals(user)){
                result = i;
            }
        }
        return result;
    }



    public void addToTriggers(String key, String value){
        triggers.put(key, value);
    }
    public void removeFromTriggers(String key){
        triggers.remove(key);
    }
    public void addToMuted(String key, String value){
        muted.put(key, value);
    }
    public void removeFromMuted(String key){
        muted.remove(key);
    }
    public void setMsgsAfterMute(String num) {
        msgsaftermute = num;
    }
}