/* Copyright 2009-2010 Edouard Garnier de Labareyre
  *
  * This file is part of B@ggle.
  *
  * B@ggle is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * B@ggle 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with B@ggle.  If not, see <http://www.gnu.org/licenses/>.
  */
 
package threads;
 
import server.Key;
import server.Main;
import server.Semaphore;
import server.Utils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
 
/**
 *
 * @author edouard
 */
public class ClientConnection extends Thread{
    public String PLAYER_NAME = "";
    public String PLAYER_AVATAR = "0";
    public int total_score = 0;
    public int score = 0;
 
    public int state=0; //0:idle, 1: ready, 2:pause, 3:reset
 
    private final ArrayList<String> words_found=new ArrayList<String>();
    private final Semaphore wfm=new Semaphore();//semaphore for words_found
 
    private PrintWriter out;
    private BufferedReader in;
    private Socket socket;
 
    public final static int max_watchdog=180;//seconds
    public double time_of_last_action=0;
 
    public boolean IS_PLAYER=true;
 
    public ClientConnection(Socket s) throws IOException{
        out = new PrintWriter(s.getOutputStream(), true);
        in = new BufferedReader(new InputStreamReader(s.getInputStream()));
        socket = s;
        if(Main.clients.isFull()){
            send(Key.SERVER_FULL+":"+Main.MAX_NUMBER_OF_PLAYERS);
            closeStreams();
        }
        this.IS_PLAYER=true;
    }
 
    @Override
    public void run(){
        Utils.printLogIfVerbose("Connection initiated...");
        //réception du premier mot
        //si commence par PING-> répondre au ping
        //si commence par NEW_PLAYER -> fonctionnement normal
        //si commence par ADMIN:password -> créer une connection de type administration
        try {
            String firstWord = in.readLine();
            if(firstWord!=null){
                if(firstWord.toUpperCase().startsWith("PING")){
                    pingRoutine();
                }
                else if(firstWord.toUpperCase().startsWith(Key.NEW_PLAYER.toString())){
                    playerRoutine(firstWord.substring(firstWord.indexOf(":")+1));
                }
                else if(firstWord.toUpperCase().startsWith("ADMIN:")){
                    if(firstWord.substring(firstWord.indexOf(":")+1).equals(Main.ADMIN_PASSWORD)){
                        adminRoutine();
                    }else{
                        Utils.printLogIfVerbose("Admin connection failed: wrong password");
                    }
                }
            }
        }catch(IOException ex){
            //do nothing
        }
        catch (Exception ex) {
            ex.printStackTrace();
        } finally{
            send(Key.DISCONNECTED+":");
            closeStreams();
            Utils.printLogIfVerbose("Connection closed");
        }
 
    }
 
    private void playerRoutine(String first_word){
        Utils.printLogIfVerbose("New player connection");
        this.IS_PLAYER=true;
        //password verification if any
        if(Main.PASSWORD.length()>0){
            try {
                String password=in.readLine();
                if(password != null){
                    if(!password.equals(Main.PASSWORD)){
                        send(Key.WRONG_PASSWORD+":");
                        closeStreams();
                        return;
                    }else{
                        send(Key.GOOD_PASSWORD+":");
                    }
                }
            } catch (IOException ex) {
                closeStreams();
            }
        }
 
        //sending informations to this new client
        Main.clients.sendInitInformationToClient(this,first_word);
        this.time_of_last_action=System.currentTimeMillis();
 
        String packet;
        Key key;
        String message;
        try {
            while ((packet = in.readLine()) != null && !packet.equals(Key.DISCONNECTED+":")){
                if(packet.contains(":") && packet.length() < Main.MAX_PAQUET_LENGTH){
                    try{
                        key = Key.valueOf(packet.substring(0, packet.indexOf(':')));
                    }catch(Exception ex){
                        key=null;
                    }
                    if(key!=null){
                        this.time_of_last_action=System.currentTimeMillis();
                        message = packet.substring(packet.indexOf(':')+1).trim();
                        switch (key){
                            case READY:
                                readyAction();
                                break;
                            case CHAT:
                                chatAction(message);
                                break;
                            case RESET:
                                resetAction();
                                break;
                            case WORD:
                                if(!Main.is_playing){
                                    chatAction(message);
                                }
                                wordAction(message.toUpperCase());
                                break;
                            case STATE:
                                statusChangeAction(message);
                                break;
                            case VERSION:
                                versionActionPlayer(message);
                                break;
                            default:
                                Utils.printLogIfVerbose("Unrecognized message from "+PLAYER_NAME+": "+message);
                                break;
                        }
                    }
                }
            }
        } catch (IOException ex) {
            Utils.printLogIfVerbose("Brutal deconnection of client "+this.PLAYER_NAME);
        }finally{
            Main.clients.disconnectClient(this);
        }
    }
 
    /**
     * Server routine for admin connection
     */
    private void adminRoutine(){
        Utils.printLogIfVerbose("New admin connection");
        this.IS_PLAYER=false;
        
        //sending informations to this new client
        Main.clients.sendInitInformationToClient(this,"");
 
        String packet;
        Key key;
        String message;
        try {
            while ((packet = in.readLine()) != null && !packet.equals(Key.DISCONNECTED+":")){
                if(packet.contains(":") && packet.length() < Main.MAX_PAQUET_LENGTH){
                    try{
                        key = Key.valueOf(packet.substring(0, packet.indexOf(':')));
                    }catch(Exception ex){
                        key=null;
                    }
                    if(key!=null){
                        message = packet.substring(packet.indexOf(':')+1).trim();
                        switch (key){
                            case CHAT:
                                chatAction(message);
                                break;
                            case VERSION:
                                versionActionAdmin();
                                break;
                            case GET_PROPERTY:
                                getPropertyActionAdmin(message);
                                break;
                            case SET_PROPERTY:
                                setPropertyActionAdmin(message);
                                break;
                            case KICK:
                                kickActionAdmin(message);
                                break;
                            default:
                                Utils.printLogIfVerbose("Unrecognized message from admin: "+message);
                                break;
                        }
                    }
                }
            }
        }catch (IOException ex) {
            Utils.printLogIfVerbose("Brutal deconnection of client "+this.PLAYER_NAME);
        }finally{
            Main.clients.disconnectClient(this);
        }
    }
 
    public void new_player(String message){
        String name = message.substring(0, message.indexOf(":"));
        if(name.length()==0){
            name="sans_nom";
        }
        this.PLAYER_NAME = Main.clients.testName(this,name);
        this.PLAYER_AVATAR = message.substring(message.indexOf(":")+1);
        try{
            int tmp = Integer.parseInt(PLAYER_AVATAR);
            if(tmp<0 || tmp > 8){
                PLAYER_AVATAR="0";
            }
        }catch(Exception e){
            PLAYER_AVATAR="0";
        }
        broadcast(Key.NEW_PLAYER+":"+PLAYER_NAME+":"+PLAYER_AVATAR);
        broadcast(Key.TOTAL_SCORE+":"+PLAYER_NAME+":0");
        broadcast(Key.INFO+":"+name+" a rejoint la partie.");
        Utils.printLog("New player: " + PLAYER_NAME );
    }
 
    public void closeStreams(){
        try {
            in.close();
            out.close();
            socket.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
 
    private void pingRoutine(){
        Utils.printLogIfVerbose("PING connection: answering and closing");
        send("PING");
        RegisterThread.keepRegistering();
    }
 
    public void addResultsTo(ArrayList<String> all){
        try{
            wfm.P(false);
            for(String a:words_found){
                if(!all.contains(a)){
                    all.add(a);
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            wfm.V();
        }
    }
 
    public String[] getAgregatedResults(ArrayList<String> all){
        String s="";
        String t="";
        int points=0;
        try{
            wfm.P(false);
            if(!Main.COUNT_ALL_WORDS){//normal mode
                for(String a: words_found){
                    if(!all.contains(a)){
                        s+=":"+a;
                        points+=Utils.getPoints(a);
                    }
                    else t+=":"+a;
                }
            }else{//all words count mode
                String[] sorted= {"","","","","","",""};
                for(String a: words_found){
                    sorted[9-a.length()]+=":"+a;
                    points+=Utils.getPoints(a);
                }
                for(String a: sorted){
                    s+=a;
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            wfm.V();
        }
        score = points;
        total_score+=score;
        String[] r = {s,t};
        return r;
    }
 
    public int getNumberOfWordsFound(){
        int result=0;
        try{
            wfm.P(false);
            result=words_found.size();
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            wfm.V();
        }
        return result;
    }
 
    public boolean isReady(){
        if(state==1) return true;
        else return false;
    }
 
    public boolean isActive(){
        if(state!=2) return true;
        else return false;
    }
 
    public boolean wantsToReset(){
        if(state==3) return true;
        else return false;
    }
 
    public void send(String message){
        out.println(message);
    }
 
    public void broadcast(String message){
        Main.clients.broadcast(message);
    }
 
    public void resetStatus() {
        if(state!=2){
            state=0;
        }
        broadcast(Key.STATE+":"+this.PLAYER_NAME+":IDLE");
    }
 
    private void readyAction() {
        if(!Main.is_playing){
            if(!this.isActive()){
                broadcast(Key.STATE+":"+PLAYER_NAME+":PLAY");
                
            }
            this.state=1;
            broadcast(Key.READY+":"+PLAYER_NAME);
            Utils.printLogIfVerbose(PLAYER_NAME + " is ready.");
        }
    }
 
    private void statusChangeAction(String message) {
        String status = message.substring(0, message.indexOf(":"));
        if(status.equals("PAUSE")){
            state=2;
            broadcast(Key.STATE+":"+PLAYER_NAME+":PAUSE");
            Utils.printLogIfVerbose(PLAYER_NAME+" is having a break.");
        }
        else if(status.equals("PLAY")){
            state=0;
            broadcast(Key.STATE+":"+PLAYER_NAME+":PLAY");
            Utils.printLogIfVerbose(PLAYER_NAME+" is back in the game !");
        }
    }
 
    private void chatAction(String message) {
        message = message.trim().replaceAll("/me", PLAYER_NAME);
        if(message.trim().length()>0){
            if(IS_PLAYER){
                broadcast(Key.CHAT+":"+PLAYER_NAME+":"+message);
                Utils.printLogIfVerbose(PLAYER_NAME + " says: "+message);
            }else{
                broadcast(Key.INFO+":"+message);
                Utils.printLogIfVerbose("Admin says: "+message);
            }
            
        }
    }
 
    private void resetAction() {
        if(this.isActive() && Main.is_playing){
            state=3;
            broadcast(Key.RESET+":"+PLAYER_NAME);
            Utils.printLogIfVerbose(PLAYER_NAME + " wants to reset the grid.");
        }
    }
 
    private void wordAction(String word) {
        if(Main.is_playing){
            if(Utils.isValid(word)){
                try{
                    wfm.P(true);
                    if(!words_found.contains(word)){
                        send(Key.GOOD+":"+word);
                        Utils.printLogIfVerbose(PLAYER_NAME + " found the word \""+word+"\".");
                        words_found.add(word);
                        Main.total_number_of_words_found++;
                        if(!this.isActive()){
                            state=0;
                            broadcast(Key.STATE+":"+PLAYER_NAME+":PLAY");
                            send(Key.STATE+":GO_TO_PLAY");
                            Utils.printLogIfVerbose(PLAYER_NAME+" is back in the game !");
                        }
                    }
                }catch(Exception e){
                    e.printStackTrace();
                }finally{
                    wfm.V();
                }
                Main.clients.broadcastGauge();
            }else{
                send(Key.BAD+":"+word);
                Utils.printLogIfVerbose(PLAYER_NAME + " found \""+word+"\" but it's false.");
            }
        }
    }
 
    /**
     * Reaction when receiving a VERSION keyword from a player
     * @param message the version
     */
    private void versionActionPlayer(String message) {
        Main.clients.broadcastToAdmins(Key.VERSION+":"+this.PLAYER_NAME+":"+message);
        Utils.printLogIfVerbose(PLAYER_NAME+" version is "+message);
    }
 
    /**
     * Reaction when receiving a VERSION keyword from an admin
     */
    private void versionActionAdmin() {
        Main.clients.broadcast(Key.VERSION+":");
        Utils.printLogIfVerbose("Admin is asking for client versions");
    }
 
    /**
     * Reaction when receiving a KICK keyword from an admin
     */
    private void kickActionAdmin(String message) {
        Utils.printLog("Kick received from admin about "+message);
        Main.clients.kickClient(message);
    }
 
    private void getPropertyActionAdmin(String message) {
 
    }
 
    private void setPropertyActionAdmin(String message) {
 
    }
 
    public void resetWordsFound() {
        try{
            wfm.P(true);
            this.words_found.clear();
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            wfm.V();
        }
    }
 
}