package com.ouxuan.oxface.device;

import android.content.Context;
import android.util.Log;

import com.esotericsoftware.kryonet.Connection;

/**
 * DeviceUDPManager 使用示例
 * 展示如何在项目中初始化和使用UDP通信功能
 * 
 * @author AI Assistant
 * @version 1.0
 */
public class DeviceUDPManagerUsageExample {
    
    private static final String TAG = "UDPManagerExample";
    private DeviceUDPManager udpManager;
    private Context context;
    
    public DeviceUDPManagerUsageExample(Context context) {
        this.context = context;
        this.udpManager = DeviceUDPManager.getInstance();
    }
    
    /**
     * 初始化为客户端模式示例
     */
    public void initializeAsClientExample() {
        // 设置消息监听器
        udpManager.setMessageListener(new DeviceUDPManager.UDPMessageListener() {
            @Override
            public void onMessageReceived(Object message, Connection connection) {
                Log.i(TAG, "收到消息: " + message + " 来自: " + connection.getRemoteAddressTCP());
                
                // 处理接收到的消息
                if (message instanceof String) {
                    String strMessage = (String) message;
                    handleStringMessage(strMessage, connection);
                }
                // 可以根据需要处理其他类型的消息
            }
            
            @Override
            public void onMessageSent(Object message) {
                Log.i(TAG, "消息发送成功: " + message);
            }
            
            @Override
            public void onMessageSendFailed(Object message, String error) {
                Log.e(TAG, "消息发送失败: " + message + ", 错误: " + error);
            }
        });
        
        // 设置连接状态监听器
        udpManager.setConnectionStateListener(new DeviceUDPManager.ConnectionStateListener() {
            @Override
            public void onConnected() {
                Log.i(TAG, "UDP连接成功");
                // 连接成功后可以发送消息
                sendTestMessage();
            }
            
            @Override
            public void onDisconnected() {
                Log.i(TAG, "UDP连接断开");
            }
            
            @Override
            public void onConnectionFailed(String error) {
                Log.e(TAG, "UDP连接失败: " + error);
            }
            
            @Override
            public void onReconnecting(int attempt) {
                Log.i(TAG, "UDP重连中，第 " + attempt + " 次尝试");
            }
        });
        
        // 设置自动重连
        udpManager.setAutoReconnect(true);
        
        // 初始化为客户端（连接到服务器）
        String serverIP = "192.168.1.100"; // 替换为实际的服务器IP
        int tcpPort = 54555;
        int udpPort = 54777;
        udpManager.initializeAsClient(context, serverIP, tcpPort, udpPort);
    }
    
    /**
     * 初始化为服务端模式示例
     */
    public void initializeAsServerExample() {
        // 设置消息监听器
        udpManager.setMessageListener(new DeviceUDPManager.UDPMessageListener() {
            @Override
            public void onMessageReceived(Object message, Connection connection) {
                Log.i(TAG, "服务端收到消息: " + message + " 来自: " + connection.getRemoteAddressTCP());
                
                // 处理接收到的消息并回复
                if (message instanceof String) {
                    String strMessage = (String) message;
                    handleServerMessage(strMessage, connection);
                }
            }
            
            @Override
            public void onMessageSent(Object message) {
                Log.i(TAG, "服务端消息发送成功: " + message);
            }
            
            @Override
            public void onMessageSendFailed(Object message, String error) {
                Log.e(TAG, "服务端消息发送失败: " + message + ", 错误: " + error);
            }
        });
        
        // 设置连接状态监听器
        udpManager.setConnectionStateListener(new DeviceUDPManager.ConnectionStateListener() {
            @Override
            public void onConnected() {
                Log.i(TAG, "服务端已准备就绪，等待客户端连接");
            }
            
            @Override
            public void onDisconnected() {
                Log.i(TAG, "客户端断开连接");
            }
            
            @Override
            public void onConnectionFailed(String error) {
                Log.e(TAG, "服务端启动失败: " + error);
            }
            
            @Override
            public void onReconnecting(int attempt) {
                // 服务端模式下通常不需要重连
            }
        });
        
        // 初始化为服务端
        int tcpPort = 54555;
        int udpPort = 54777;
        udpManager.initializeAsServer(context, tcpPort, udpPort);
    }
    
    /**
     * 发送测试消息
     */
    public void sendTestMessage() {
        if (udpManager.isConnected()) {
            // 发送字符串消息
            udpManager.sendUDPMessage("Hello from Android device!");
            
            // 发送JSON格式的消息
            String jsonMessage = "{\"type\":\"device_status\",\"status\":\"online\",\"timestamp\":" + System.currentTimeMillis() + "}";
            udpManager.sendUDPMessage(jsonMessage);
            
            // 发送数字消息
            udpManager.sendUDPMessage(12345);
        } else {
            Log.w(TAG, "UDP未连接，无法发送消息");
        }
    }
    
    /**
     * 处理接收到的字符串消息（客户端）
     */
    private void handleStringMessage(String message, Connection connection) {
        Log.d(TAG, "处理字符串消息: " + message);
        
        // 根据消息内容进行不同处理
        if (message.startsWith("{")) {
            // JSON格式消息
            handleJsonMessage(message, connection);
        } else if (message.equals("ping")) {
            // 心跳消息
            udpManager.sendUDPMessage("pong");
        } else if (message.startsWith("command:")) {
            // 命令消息
            String command = message.substring(8);
            handleCommand(command, connection);
        } else {
            // 普通文本消息
            Log.i(TAG, "收到普通文本消息: " + message);
        }
    }
    
    /**
     * 处理服务端接收到的消息
     */
    private void handleServerMessage(String message, Connection connection) {
        Log.d(TAG, "服务端处理消息: " + message);
        
        // 服务端可以回复消息给特定客户端
        if (message.equals("ping")) {
            udpManager.sendUDPMessageToConnection(connection, "pong");
        } else if (message.equals("get_status")) {
            String status = "{\"server_status\":\"running\",\"timestamp\":" + System.currentTimeMillis() + "}";
            udpManager.sendUDPMessageToConnection(connection, status);
        } else {
            // 回复确认消息
            udpManager.sendUDPMessageToConnection(connection, "message_received: " + message);
        }
    }
    
    /**
     * 处理JSON格式消息
     */
    private void handleJsonMessage(String jsonMessage, Connection connection) {
        try {
            Log.d(TAG, "处理JSON消息: " + jsonMessage);
            // 这里可以使用Gson或其他JSON库解析消息
            // 示例：设备状态更新、配置同步等
        } catch (Exception e) {
            Log.e(TAG, "解析JSON消息失败", e);
        }
    }
    
    /**
     * 处理命令消息
     */
    private void handleCommand(String command, Connection connection) {
        Log.d(TAG, "处理命令: " + command);
        
        switch (command) {
            case "restart":
                Log.i(TAG, "收到重启命令");
                // 执行重启逻辑
                break;
            case "get_config":
                Log.i(TAG, "收到获取配置命令");
                // 返回当前配置
                udpManager.sendUDPMessage("{\"config\":{\"version\":\"1.0\",\"mode\":\"production\"}}");
                break;
            case "shutdown":
                Log.i(TAG, "收到关闭命令");
                // 执行关闭逻辑
                break;
            default:
                Log.w(TAG, "未知命令: " + command);
                break;
        }
    }
    
    /**
     * 手动重连
     */
    public void reconnect() {
        if (udpManager.isClientMode()) {
            udpManager.reconnect();
        }
    }
    
    /**
     * 停止UDP管理器
     */
    public void stop() {
        udpManager.stop();
    }
    
    /**
     * 获取连接状态
     */
    public boolean isConnected() {
        return udpManager.isConnected();
    }
    
    /**
     * 在Activity或Service中的使用示例
     */
    public static class IntegrationExample {
        
        /**
         * 在Application中初始化（推荐）
         */
        public static void initializeInApplication(Context context) {
            DeviceUDPManagerUsageExample example = new DeviceUDPManagerUsageExample(context);
            
            // 根据设备角色选择模式
            boolean isServer = isCurrentDeviceServer(); // 自定义逻辑判断
            
            if (isServer) {
                example.initializeAsServerExample();
            } else {
                example.initializeAsClientExample();
            }
        }
        
        /**
         * 在Activity中使用
         */
        public static void useInActivity(Context context) {
            DeviceUDPManager manager = DeviceUDPManager.getInstance();
            
            // 检查连接状态
            if (manager.isConnected()) {
                // 发送设备状态消息
                String deviceInfo = "{\"device_id\":\"" + android.os.Build.MODEL + "\",\"timestamp\":" + System.currentTimeMillis() + "}";
                manager.sendUDPMessage(deviceInfo);
            }
        }
        
        /**
         * 判断当前设备是否应该作为服务端
         * 这里可以根据具体业务逻辑实现
         */
        private static boolean isCurrentDeviceServer() {
            // 示例：可以根据设备配置、IP地址范围、设备类型等判断
            // 这里简单返回false，实际使用时需要根据业务需求实现
            return false;
        }
    }
}