// NetworkBase.java - 网络通信基类
package home;

import java.io.IOException;
import java.net.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;

public abstract class NetworkBase {
    protected AtomicBoolean isRunning = new AtomicBoolean(false);
    protected String host;
    protected int port;
    protected NetworkDataListener dataListener;

    // 新增：响应消费者，用于处理特定的响应数据
    protected Consumer<byte[]> responseConsumer;

    public interface NetworkDataListener {
        void onDataReceived(byte[] data, String fromAddress);
        void onStatusChanged(String status, boolean isConnected);
        void onError(String errorMessage);
    }

    public void setDataListener(NetworkDataListener listener) {
        this.dataListener = listener;
    }

    /**
     * 设置响应消费者 - 新增方法
     * 用于处理特定的响应数据，比如配置读取的响应
     */
    public void setResponseConsumer(Consumer<byte[]> consumer) {
        this.responseConsumer = consumer;
    }

    /**
     * 获取响应消费者 - 新增方法
     */
    public Consumer<byte[]> getResponseConsumer() {
        return responseConsumer;
    }

    /**
     * 通知响应数据 - 新增方法
     * 如果有设置响应消费者，将数据传递给消费者
     */
    protected void notifyResponseData(byte[] data) {
        if (responseConsumer != null) {
            responseConsumer.accept(data);
        }
    }

    /**
     * 处理接收到的数据 - 新增方法
     * 同时通知数据监听器和响应消费者
     */
    protected void handleReceivedData(byte[] data, String fromAddress) {
        // 通知数据监听器
        notifyData(data, fromAddress);

        // 通知响应消费者
        notifyResponseData(data);
    }

    public abstract boolean start() throws Exception;
    public abstract void stop();
    public abstract boolean sendData(String data) throws Exception;
    public abstract boolean isConnected();

    protected void notifyStatus(String status, boolean connected) {
        if (dataListener != null) {
            dataListener.onStatusChanged(status, connected);
        }
    }

    protected void notifyError(String error) {
        if (dataListener != null) {
            dataListener.onError(error);
        }
    }

    protected void notifyData(byte[] data, String fromAddress) {
        if (dataListener != null) {
            dataListener.onDataReceived(data, fromAddress);
        }
    }

    /**
     * 获取数据监听器
     */
    public NetworkDataListener getDataListener() {
        return dataListener;
    }
}