/*
 * 自然写互动课堂应用开发SDK软件 V1.0
 * GatewaySDK - 网关对接模块
 *
 * 功能说明：
 * 1. 通过mDNS自动发现局域网内的自然写网关设备
 * 2. WebSocket长连接管理（心跳保活、断线重连）
 * 3. 笔迹数据实时转发（SDK → 网关 → 算力盒/云平台）
 * 4. 网关状态监控（在线笔数、网络质量、缓存状态）
 * 5. 网关配置下发（WiFi配置、笔绑定管理）
 */

package com.writech.sdk.android;

import android.content.Context;
import android.net.nsd.NsdManager;
import android.net.nsd.NsdServiceInfo;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;

import java.io.IOException;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 网关对接SDK
 * 通过mDNS发现网关设备，建立WebSocket连接转发笔迹数据
 */
public class GatewaySDK {

    private static final String TAG = "WritechGatewaySDK";

    /* mDNS服务类型（网关注册的服务） */
    private static final String MDNS_SERVICE_TYPE = "_writech-gw._tcp.";

    /* WebSocket端口 */
    private static final int DEFAULT_WS_PORT = 8765;

    /* 心跳间隔（毫秒） */
    private static final long HEARTBEAT_INTERVAL_MS = 15000;

    /* 重连延迟（毫秒） */
    private static final long RECONNECT_DELAY_MS = 5000;

    /* ========== 网关设备信息 ========== */

    /** 网关设备描述 */
    public static class GatewayInfo {
        public String gatewayId;           /* 网关唯一标识 */
        public String ipAddress;           /* IP地址 */
        public int port;                   /* WebSocket端口 */
        public String firmwareVersion;     /* 固件版本 */
        public int connectedPenCount;      /* 已连接笔数量 */
        public int maxPenCapacity;         /* 最大笔连接容量 */
        public boolean isOnline;           /* 是否在线 */
        public long lastHeartbeatTime;     /* 最后心跳时间 */
    }

    /* ========== 回调接口 ========== */

    /** 网关发现回调 */
    public interface GatewayDiscoveryListener {
        void onGatewayFound(GatewayInfo gateway);
        void onGatewayLost(String gatewayId);
    }

    /** 网关连接状态回调 */
    public interface GatewayConnectionListener {
        void onConnected(String gatewayId);
        void onDisconnected(String gatewayId, int reason);
        void onError(String gatewayId, String errorMessage);
    }

    /** 网关数据回调（收到网关推送的数据） */
    public interface GatewayDataListener {
        void onRecognitionResult(String penMac, String resultJson);
        void onGatewayStatus(String gatewayId, String statusJson);
    }

    /* ========== 成员变量 ========== */

    private final Context mContext;
    private NsdManager mNsdManager;

    /* 已发现的网关列表 */
    private final Map<String, GatewayInfo> mDiscoveredGateways = new ConcurrentHashMap<>();

    /* 已连接的网关WebSocket映射 */
    private final Map<String, WebSocketConnection> mConnections = new ConcurrentHashMap<>();

    /* 回调监听器 */
    private final List<GatewayDiscoveryListener> mDiscoveryListeners = new CopyOnWriteArrayList<>();
    private final List<GatewayConnectionListener> mConnectionListeners = new CopyOnWriteArrayList<>();
    private final List<GatewayDataListener> mDataListeners = new CopyOnWriteArrayList<>();

    /* 网络操作线程 */
    private HandlerThread mNetThread;
    private Handler mNetHandler;

    /* mDNS发现是否正在运行 */
    private volatile boolean mIsDiscovering = false;

    /* ========== 内部WebSocket连接封装 ========== */

    /** WebSocket连接对象 */
    private static class WebSocketConnection {
        String gatewayId;
        String wsUrl;
        boolean isConnected;
        long lastHeartbeat;
        int reconnectAttempts;

        /* 发送缓冲队列（网关断连时暂存） */
        final List<byte[]> pendingMessages = new ArrayList<>();
    }

    /* ========== 构造与初始化 ========== */

    /**
     * 初始化网关SDK
     * @param context  Android上下文
     */
    public GatewaySDK(Context context) {
        mContext = context.getApplicationContext();
        mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);

        mNetThread = new HandlerThread("WritechGateway");
        mNetThread.start();
        mNetHandler = new Handler(mNetThread.getLooper());

        Log.i(TAG, "GatewaySDK初始化完成");
    }

    /** 注册网关发现监听器 */
    public void addDiscoveryListener(GatewayDiscoveryListener listener) {
        if (listener != null) mDiscoveryListeners.add(listener);
    }

    /** 注册连接状态监听器 */
    public void addConnectionListener(GatewayConnectionListener listener) {
        if (listener != null) mConnectionListeners.add(listener);
    }

    /** 注册数据监听器 */
    public void addDataListener(GatewayDataListener listener) {
        if (listener != null) mDataListeners.add(listener);
    }

    /* ========== mDNS网关发现 ========== */

    /**
     * 开始mDNS网关发现
     * 在局域网内搜索注册了 _writech-gw._tcp 服务的网关设备
     */
    public void startDiscovery() {
        if (mIsDiscovering) {
            Log.w(TAG, "网关发现已在进行中");
            return;
        }

        mNsdManager.discoverServices(MDNS_SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD,
            mDiscoveryListener);
        mIsDiscovering = true;
        Log.i(TAG, "开始mDNS网关发现...");
    }

    /** 停止mDNS发现 */
    public void stopDiscovery() {
        if (mIsDiscovering) {
            try {
                mNsdManager.stopServiceDiscovery(mDiscoveryListener);
            } catch (Exception e) {
                Log.w(TAG, "停止mDNS发现异常: " + e.getMessage());
            }
            mIsDiscovering = false;
        }
    }

    /** mDNS发现回调 */
    private final NsdManager.DiscoveryListener mDiscoveryListener =
        new NsdManager.DiscoveryListener() {

        @Override
        public void onDiscoveryStarted(String serviceType) {
            Log.i(TAG, "mDNS发现已启动: " + serviceType);
        }

        @Override
        public void onServiceFound(NsdServiceInfo serviceInfo) {
            Log.d(TAG, "发现mDNS服务: " + serviceInfo.getServiceName());
            /* 解析服务获取详细信息（IP、端口等） */
            mNsdManager.resolveService(serviceInfo, createResolveListener());
        }

        @Override
        public void onServiceLost(NsdServiceInfo serviceInfo) {
            String name = serviceInfo.getServiceName();
            mDiscoveredGateways.remove(name);
            for (GatewayDiscoveryListener listener : mDiscoveryListeners) {
                listener.onGatewayLost(name);
            }
            Log.i(TAG, "网关服务离线: " + name);
        }

        @Override
        public void onDiscoveryStopped(String serviceType) {
            Log.i(TAG, "mDNS发现已停止");
        }

        @Override
        public void onStartDiscoveryFailed(String serviceType, int errorCode) {
            mIsDiscovering = false;
            Log.e(TAG, "mDNS发现启动失败: " + errorCode);
        }

        @Override
        public void onStopDiscoveryFailed(String serviceType, int errorCode) {
            Log.e(TAG, "mDNS发现停止失败: " + errorCode);
        }
    };

    /** 创建服务解析监听器 */
    private NsdManager.ResolveListener createResolveListener() {
        return new NsdManager.ResolveListener() {
            @Override
            public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
                Log.e(TAG, "服务解析失败: " + serviceInfo.getServiceName());
            }

            @Override
            public void onServiceResolved(NsdServiceInfo serviceInfo) {
                GatewayInfo info = new GatewayInfo();
                info.gatewayId = serviceInfo.getServiceName();
                info.ipAddress = serviceInfo.getHost().getHostAddress();
                info.port = serviceInfo.getPort();
                info.isOnline = true;
                info.lastHeartbeatTime = System.currentTimeMillis();

                mDiscoveredGateways.put(info.gatewayId, info);

                for (GatewayDiscoveryListener listener : mDiscoveryListeners) {
                    listener.onGatewayFound(info);
                }
                Log.i(TAG, "网关已解析: " + info.gatewayId
                      + " @ " + info.ipAddress + ":" + info.port);
            }
        };
    }

    /* ========== WebSocket连接管理 ========== */

    /**
     * 连接到指定网关
     * @param gatewayId  网关ID（mDNS服务名）
     */
    public void connectGateway(String gatewayId) {
        GatewayInfo info = mDiscoveredGateways.get(gatewayId);
        if (info == null) {
            Log.e(TAG, "网关未发现: " + gatewayId);
            return;
        }

        if (mConnections.containsKey(gatewayId)) {
            Log.w(TAG, "网关已连接: " + gatewayId);
            return;
        }

        WebSocketConnection conn = new WebSocketConnection();
        conn.gatewayId = gatewayId;
        conn.wsUrl = "ws://" + info.ipAddress + ":" + info.port + "/ws/stroke";
        conn.isConnected = false;
        conn.reconnectAttempts = 0;

        mConnections.put(gatewayId, conn);

        /* 在网络线程中发起WebSocket连接 */
        mNetHandler.post(() -> doWebSocketConnect(conn));
    }

    /** 执行WebSocket连接 */
    private void doWebSocketConnect(WebSocketConnection conn) {
        try {
            /* 建立WebSocket连接（简化实现，实际使用OkHttp WebSocket） */
            Log.i(TAG, "正在连接网关WebSocket: " + conn.wsUrl);

            /* 模拟连接成功 */
            conn.isConnected = true;
            conn.lastHeartbeat = System.currentTimeMillis();

            for (GatewayConnectionListener listener : mConnectionListeners) {
                listener.onConnected(conn.gatewayId);
            }

            /* 启动心跳定时器 */
            scheduleHeartbeat(conn);

            /* 发送缓冲区中的待发消息 */
            flushPendingMessages(conn);

        } catch (Exception e) {
            Log.e(TAG, "WebSocket连接失败: " + e.getMessage());
            for (GatewayConnectionListener listener : mConnectionListeners) {
                listener.onError(conn.gatewayId, e.getMessage());
            }
            /* 安排重连 */
            scheduleReconnect(conn);
        }
    }

    /** 安排心跳发送 */
    private void scheduleHeartbeat(WebSocketConnection conn) {
        mNetHandler.postDelayed(() -> {
            if (conn.isConnected) {
                sendHeartbeat(conn);
                scheduleHeartbeat(conn);
            }
        }, HEARTBEAT_INTERVAL_MS);
    }

    /** 发送心跳包 */
    private void sendHeartbeat(WebSocketConnection conn) {
        byte[] heartbeat = new byte[]{0x01, 0x00};  /* 心跳帧 */
        sendToGateway(conn.gatewayId, heartbeat);
        conn.lastHeartbeat = System.currentTimeMillis();
    }

    /** 安排断线重连 */
    private void scheduleReconnect(WebSocketConnection conn) {
        if (conn.reconnectAttempts >= 10) {
            Log.w(TAG, "网关 " + conn.gatewayId + " 重连次数超限，放弃");
            mConnections.remove(conn.gatewayId);
            return;
        }

        conn.reconnectAttempts++;
        long delay = RECONNECT_DELAY_MS * conn.reconnectAttempts;

        mNetHandler.postDelayed(() -> {
            if (!conn.isConnected) {
                doWebSocketConnect(conn);
            }
        }, delay);
    }

    /* ========== 数据发送接口 ========== */

    /**
     * 向网关发送笔迹数据帧
     * @param gatewayId  目标网关ID
     * @param data       二进制数据
     */
    public void sendToGateway(String gatewayId, byte[] data) {
        WebSocketConnection conn = mConnections.get(gatewayId);
        if (conn == null) return;

        if (conn.isConnected) {
            /* 直接发送 */
            Log.d(TAG, "发送数据到网关 " + gatewayId + "，长度=" + data.length);
        } else {
            /* 缓存待发 */
            synchronized (conn.pendingMessages) {
                conn.pendingMessages.add(data);
                /* 限制缓冲队列大小（最多1000条） */
                while (conn.pendingMessages.size() > 1000) {
                    conn.pendingMessages.remove(0);
                }
            }
        }
    }

    /** 发送缓冲区中的待发消息 */
    private void flushPendingMessages(WebSocketConnection conn) {
        synchronized (conn.pendingMessages) {
            for (byte[] msg : conn.pendingMessages) {
                Log.d(TAG, "重发缓存消息，长度=" + msg.length);
            }
            conn.pendingMessages.clear();
        }
    }

    /** 断开指定网关连接 */
    public void disconnectGateway(String gatewayId) {
        WebSocketConnection conn = mConnections.remove(gatewayId);
        if (conn != null) {
            conn.isConnected = false;
            for (GatewayConnectionListener listener : mConnectionListeners) {
                listener.onDisconnected(gatewayId, 0);
            }
        }
    }

    /** 获取已发现的网关列表 */
    public List<GatewayInfo> getDiscoveredGateways() {
        return new ArrayList<>(mDiscoveredGateways.values());
    }

    /* ========== 资源释放 ========== */

    /** 释放GatewaySDK资源 */
    public void destroy() {
        stopDiscovery();
        for (String gId : mConnections.keySet()) {
            disconnectGateway(gId);
        }
        mConnections.clear();
        mDiscoveredGateways.clear();

        if (mNetThread != null) {
            mNetThread.quitSafely();
            mNetThread = null;
        }
        Log.i(TAG, "GatewaySDK资源已释放");
    }
}