package server;

import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;

/**
 * 顯示服務器及用戶信息的Panel類
 */
class MessageServerPanel extends Panel {
    // 主消息窗口
    TextArea messageBoard = new TextArea("", 22, 50, TextArea.SCROLLBARS_VERTICAL_ONLY);

    Label statusLabel = new Label("當前連接數:", Label.LEFT);

    Panel boardPanel = new Panel();// 主顯示區Panel

    Panel statusPanel = new Panel();// 連接狀態Panel

    MessageServerPanel() {
        setSize(350, 300);
        setBackground(new Color(204, 204, 204));
        setLayout(new BorderLayout());
        boardPanel.setLayout(new FlowLayout());
        boardPanel.setSize(210, 210);
        statusPanel.setLayout(new BorderLayout());
        statusPanel.setSize(210, 50);
        boardPanel.add(messageBoard);
        statusPanel.add(statusLabel, BorderLayout.WEST);
        add(boardPanel, BorderLayout.CENTER);
        add(statusPanel, BorderLayout.NORTH);
    }
}

/**
 * 服務器線程,主要用于服務器與客戶端的通信
 */
class ServerThread extends Thread {
    Socket clientSocket;

    Hashtable clientDataHash;// Socket與發送數據的流的映射

    Hashtable clientNameHash;// Socket與用戶名的映射

    Hashtable chessPeerHash;// 對弈的兩個客戶端用戶名的映射

    MessageServerPanel server;

    boolean isClientClosed = false;

    /**
     * 服務器端線程的構造函數，用于初始化一些對象。
     */
    ServerThread(Socket clientSocket, Hashtable clientDataHash, Hashtable clientNameHash, Hashtable chessPeerHash,
            MessageServerPanel server) {
        this.clientSocket = clientSocket;
        this.clientDataHash = clientDataHash;
        this.clientNameHash = clientNameHash;
        this.chessPeerHash = chessPeerHash;
        this.server = server;
    }

    /**
     * 對客戶端發來的消息處理的函數，處理后轉發回客戶端。處理消息的過程比較復雜， 要針對很多種情況分別處理。
     */
    public void messageTransfer(String message) {
        String clientName, peerName;
        /////////////命令處理///////////////////////////////
        // 如果消息以“/”開頭，表明是命令消息。
        if (message.startsWith("/")) {

            // 如果消息以“/list”開頭，則將其回饋到客戶端以更新用戶列表
            if (message.equals("/list")) {
                Feedback(getUserList());
            }
            // 如果消息以"/creatgame [inchess]"開頭，則修改clientNameHash映射
            // 和chessPeerHash映射。
            else if (message.startsWith("/creatgame [inchess]")) {
                //
                String chessServerName = message.substring(20);
                synchronized (clientNameHash) {
                    clientNameHash.put(clientSocket, message.substring(11));
                }
                synchronized (chessPeerHash) {//剛創建，等待其他人加入
                    chessPeerHash.put(chessServerName, "wait");
                }
                Feedback("/yourname " + clientNameHash.get(clientSocket));
                chessPeerTalk(chessServerName, "/OK");
                publicTalk(getUserList());
            }
            // 如果消息以“/joingame”開頭，則將消息的服務端名字和本地用戶名提取出來，
            // 然后修改clientNameHash表和chessPeerHash表。
            if (message.startsWith("/joingame ")) {
                StringTokenizer userToken = new StringTokenizer(message, " ");
                String getUserToken, serverName, selfName;
                String[] chessNameOpt = {"0", "0"};
                int getOptNum = 0;
                // 提取服務端用戶名和本地用戶名
                while (userToken.hasMoreTokens()) {
                    getUserToken = (String) userToken.nextToken(" ");
                    if (getOptNum >= 1 && getOptNum <= 2) {
                        chessNameOpt[getOptNum - 1] = getUserToken;
                    }
                    getOptNum++;
                }
                serverName = chessNameOpt[0];
                selfName = chessNameOpt[1];
                // 如果有服務端在等待開始棋局
                if (chessPeerHash.containsKey(serverName) && chessPeerHash.get(serverName).equals("wait")) {
                    // 修改Socket和名字映射
                    synchronized (clientNameHash) {
                        clientNameHash.put(clientSocket, ("[inchess]" + selfName));
                    }
                    // 修改chessPeerHash映射
                    synchronized (chessPeerHash) {
                        chessPeerHash.put(serverName, selfName);
                    }
                    publicTalk(getUserList());
                    chessPeerTalk(selfName, ("/peer " + "[inchess]" + serverName));
                    chessPeerTalk(serverName, ("/peer " + "[inchess]" + selfName));
                } else {
                    chessPeerTalk(selfName, "/reject");
                    try {
                        clientClose();
                    } catch (Exception ez) {
                    }
                }
            }
            // 如果消息以“/[inchess]”開頭，則獲取要發送消息的用戶名和發送的消息
            // 然后發送出去。
            else if (message.startsWith("/[inchess]")) {
                int firstLocation = 0, lastLocation;

                lastLocation = message.indexOf(" ", 0);

                peerName = message.substring((firstLocation + 1), lastLocation);
                message = message.substring((lastLocation + 1));
                if (chessPeerTalk(peerName, message)) {
                    Feedback("/error");
                }
            }
            // 如果消息以“/giveup”開頭，則判斷是對弈雙方哪方放棄了。
            else if (message.startsWith("/giveup ")) {
                String chessClientName = message.substring(8);
                if (chessPeerHash.containsKey(chessClientName)
                        && !((String) chessPeerHash.get(chessClientName)).equals("wait")) {
                    // 如果服務方放棄，則發送消息“/youwin”表明對方獲勝
                    chessPeerTalk((String) chessPeerHash.get(chessClientName), "/youwin");
                    //剔除這對對弈的人。。
                    synchronized (chessPeerHash) {
                        chessPeerHash.remove(chessClientName);
                    }
                }
                if (chessPeerHash.containsValue(chessClientName)) {
                    // 如果客戶方放棄，也發送消息“/youwin”表明對方獲勝
                    chessPeerTalk((String) getHashKey(chessPeerHash, chessClientName), "/youwin");
                    synchronized (chessPeerHash) {
                        chessPeerHash.remove((String) getHashKey(chessPeerHash, chessClientName));
                    }
                }
            }
            // 如果找不到發送消息的用戶，則輸出消息說“沒有這個用戶”
            else {
                int firstLocation = 0, lastLocation;
                lastLocation = message.indexOf(" ", 0);
                if (lastLocation == -1) {
                    Feedback("無效命令");
                    return;
                } else {
                    peerName = message.substring((firstLocation + 1), lastLocation);
                    message = message.substring((lastLocation + 1));
                    message = (String) clientNameHash.get(clientSocket) + ">" + message;
                    if (peerTalk(peerName, message)) {
                        Feedback("沒有這個用戶:" + peerName + "\n");
                    }
                }

            }

        }
        // //////////////////////////////////////////////
        // 如果不以“/”開頭，表明是普通消息，直接發送
        else {
            message = clientNameHash.get(clientSocket) + ">" + message;
            server.messageBoard.append(message + "\n");
            publicTalk(message);
            server.messageBoard.setCaretPosition(server.messageBoard.getText().length());
        }

    }

    /**
     * 發送公共消息的函數，將消息向每個客戶端都發送一份
     */
    public void publicTalk(String publicTalkMessage) {

        synchronized (clientDataHash) {
            //枚舉遍歷所有客戶端輸出流。。
            for (Enumeration enu = clientDataHash.elements(); enu.hasMoreElements();) {
                DataOutputStream outData = (DataOutputStream) enu.nextElement();
                try {
                    //輸出信息。。這里會阻塞
                    outData.writeUTF(publicTalkMessage);
                } catch (IOException es) {
                    //打印異常堆棧。。。終止程序。。
                    es.printStackTrace();
                }
            }
        }
    }

    /**
     * 選擇對象發送消息，參數peerTalk為發送的用戶名，后面的參數為發送的消息
     */
    public boolean peerTalk(String peerTalk, String talkMessage) {
        //
        for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();) {
            Socket userClient = (Socket) enu.nextElement();
            // 找到發送消息的對象，獲取它的輸出流以發送消息
            if (peerTalk.equals((String) clientNameHash.get(userClient))
                    && !peerTalk.equals((String) clientNameHash.get(clientSocket))) {
                synchronized (clientDataHash) {
                    DataOutputStream peerOutData = (DataOutputStream) clientDataHash.get(userClient);
                    try {
                        peerOutData.writeUTF(talkMessage);
                    } catch (IOException es) {
                        es.printStackTrace();
                    }
                }
                Feedback(talkMessage);
                return (false);
            }
            // 如果是發給自己的，直接回饋
            else if (peerTalk.equals((String) clientNameHash.get(clientSocket))) {
                Feedback(talkMessage);
                return (false);
            }
        }

        return (true);

    }

    /**
     * 此函數也用于選擇發送消息，但不能發送給自己。
     */