// TcpClient.java
package home;

import java.io.*;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.Locale;
import java.util.ResourceBundle;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.PropertyResourceBundle;

public class TcpClient extends NetworkBase {
	
	/**
	 * 获取资源包
	 */
	private static ResourceBundle getResourceBundle() {
		try {
			Locale locale = Locale.SIMPLIFIED_CHINESE; // 默认中文
			String fileName = locale.equals(Locale.ENGLISH) ? 
					"Messages_en.properties" : "Messages_zh.properties";
			File langFile = new File("systemfile/" + fileName);
			if (langFile.exists()) {
				try (InputStream inputStream = new FileInputStream(langFile)) {
					return new PropertyResourceBundle(inputStream);
				}
			}
		} catch (Exception e) {
			// 如果加载失败，使用默认
		}
		return null;
	}
	
	/**
	 * 获取国际化字符串
	 */
	private static String getString(String key) {
		ResourceBundle bundle = getResourceBundle();
		if (bundle != null) {
			try {
				return bundle.getString(key);
			} catch (Exception e) {
				// 如果找不到键，返回默认值
			}
		}
		// 默认中文值
		if ("connection.failed.check.server".equals(key)) {
			return "连接失败，请检查服务器端";
		}
		if ("tcp.client.connected".equals(key)) {
			return "TCP客户端已连接";
		}
		if ("tcp.client.disconnected".equals(key)) {
			return "TCP客户端已断开";
		}
		return key;
	}
    private Socket socket;
    private OutputStream outputStream;
    private InputStream inputStream;
    private ExecutorService receiverThread;

    public TcpClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    public boolean start() throws Exception {
        try {
            socket = new Socket();
            socket.connect(new java.net.InetSocketAddress(host, port), 5000); // 5秒连接超时
            socket.setSoTimeout(1000);

            outputStream = socket.getOutputStream();
            inputStream = socket.getInputStream();

            isRunning.set(true);
            startReceiver();
            notifyStatus(getString("tcp.client.connected") + " - " + host + ":" + port, true);
            return true;

        } catch (Exception e) {
            notifyError(getString("connection.failed.check.server") + ": " + e.getMessage());
            return false;
        }
    }

    @Override
    public void stop() {
        isRunning.set(false);
        try {
            if (outputStream != null) outputStream.close();
            if (inputStream != null) inputStream.close();
            if (socket != null) socket.close();
        } catch (Exception e) {
            // 忽略关闭时的异常
        }
        if (receiverThread != null) {
            receiverThread.shutdownNow();
        }
        notifyStatus(getString("tcp.client.disconnected"), false);
    }

    @Override
    public boolean sendData(String data) throws Exception {
        if (outputStream != null && !socket.isClosed()) {
            try {
                outputStream.write(data.getBytes());
                outputStream.flush();
                return true;
            } catch (IOException e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 发送字节数据
     */
    public boolean sendData(byte[] data) throws Exception {
        if (outputStream != null && !socket.isClosed()) {
            try {
                outputStream.write(data);
                outputStream.flush();
                return true;
            } catch (IOException e) {
                return false;
            }
        }
        return false;
    }

    @Override
    public boolean isConnected() {
        return isRunning.get() && socket != null && !socket.isClosed() && socket.isConnected();
    }

    private void startReceiver() {
        receiverThread = Executors.newSingleThreadExecutor();
        receiverThread.execute(() -> {
            byte[] buffer = new byte[1024];
            while (isRunning.get() && socket != null && !socket.isClosed()) {
                try {
                    int bytesRead = inputStream.read(buffer);
                    if (bytesRead > 0) {
                        byte[] receivedData = new byte[bytesRead];
                        System.arraycopy(buffer, 0, receivedData, 0, bytesRead);
                        String fromAddress = socket.getInetAddress().getHostAddress() + ":" + socket.getPort();

                        // 调用字节数组版本的notifyData方法
                        notifyData(receivedData, fromAddress);
                    } else if (bytesRead == -1) {
                        // 服务器断开连接
                        break;
                    }
                } catch (SocketTimeoutException e) {
                    // 超时正常，继续循环检查停止状态
                } catch (Exception e) {
                    if (isRunning.get()) {
                        //notifyError("接收数据错误: " + e.getMessage());
                        stop();
                    }
                }
            }
        });
    }

    /**
     * 通知数据接收（字节数组版本）
     */
    protected void notifyData(byte[] data, String fromAddress) {
        if (dataListener != null) {
            dataListener.onDataReceived(data, fromAddress);
        }
    }
}