package com.mogo.telematic;

import android.content.Context;
import android.net.nsd.NsdServiceInfo;

import com.elegant.log.simplelog.Logger;
import com.mogo.telematic.client.NettyTcpClient;
import com.mogo.telematic.client.NsdClient;
import com.mogo.telematic.client.listener.MessageStateListener;
import com.mogo.telematic.client.listener.NettyClientListener;
import com.mogo.telematic.server.NSDServer;
import com.mogo.telematic.server.netty.NettyServerListener;
import com.mogo.telematic.server.netty.NettyTcpServer;

import io.netty.channel.Channel;
import io.netty.channel.ChannelFutureListener;


public class NSDNettyManager {

    private static final String TAG = "NSDNettyManager";

    private volatile static NSDNettyManager sInstance;
    // client端用来过滤的
    public static final String SERVER_NAME = "NSD_SERVER";
    private NSDServer mNsdServer;
    private NettyTcpClient mNettyTcpClient;
    private NsdClient mNsdClient;
    private Context mContext;
    private NettyServerListener mListener;

    private NSDNettyManager() {
    }

    public static NSDNettyManager getInstance() {
        if (sInstance == null) {
            synchronized (NSDNettyManager.class) {
                if (sInstance == null) {
                    sInstance = new NSDNettyManager();
                }
            }
        }
        return sInstance;
    }

    private final NettyServerListener mDefaultServerListener = new NettyServerListener() {

        @Override
        public void onMessageResponseServer(Object msg, Channel channel) {
            if (msg instanceof MogoProtocolMsg && mListener != null) {
                mListener.onMessageResponseServer(msg, channel);
            }
        }

        @Override
        public void onStartServer() {
            registerNsdServer();
            if (mListener != null) {
                mListener.onStartServer();
            }
        }

        @Override
        public void onStopServer() {
            if (mNsdServer != null) {
                mNsdServer.stopNSDServer();
            }
            if (mListener != null) {
                mListener.onStopServer();
            }
        }

        @Override
        public void onChannelConnect(Channel channel) {
            if (mListener != null) {
                mListener.onChannelConnect(channel);
            }
        }

        @Override
        public void onChannelDisConnect(Channel channel) {
            if (mListener != null) {
                mListener.onChannelDisConnect(channel);
            }
        }
    };

    /**
     * 启动Netty和NSD服务的Server端
     *
     * @param context
     * @param listener
     */
    public void startNSDNettyServer(Context context, NettyServerListener listener) {
        if (context == null) {
            throw new RuntimeException("Context must not be null!");
        } else {
            mContext = context;
        }
        mListener = listener;
        NettyTcpServer nettyTcpServer = NettyTcpServer.getInstance();
        if (!nettyTcpServer.isServerStart()) {
            nettyTcpServer.setListener(mDefaultServerListener);
            nettyTcpServer.start();
        } else {
            Logger.i(TAG, "服务端已开启，断开连接！");
            NettyTcpServer.getInstance().disconnect();
        }
    }

    public void startNSDNettyServerWithSN(Context context, NettyServerListener listener, String sn) {
        NettyTcpServer.sSERVER_SN = sn;
        startNSDNettyServer(context, listener);
    }

    public boolean isServerStart() {
        return NettyTcpServer.getInstance().isServerStart();
    }

    public void sendMogoProtocolMsgToClient(MogoProtocolMsg mogoProtocolMsg, ChannelFutureListener listener) {
        NettyTcpServer.getInstance().sendMsgToClient(mogoProtocolMsg, listener);
    }

    public void sendMsgToAllClients(MogoProtocolMsg mogoProtocolMsg) {
        NettyTcpServer.getInstance().sendMsgToAllClients(mogoProtocolMsg);
    }

    public void sendMsgToSpecifiedClient(MogoProtocolMsg mogoProtocolMsg, Channel channel, ChannelFutureListener listener) {
        NettyTcpServer.getInstance().sendMsgToSpecifiedClient(mogoProtocolMsg, channel, listener);
    }

    /**
     * 服务器端注册一个可供NSD探测到的网络 Ip 地址，便于给展示叫号机连接此socket
     */
    private final Runnable mNsdServerRunnable = new Runnable() {
        @Override
        public void run() {
            if (mNsdServer == null) {
                mNsdServer = new NSDServer();
            }
            mNsdServer.startNSDServer(mContext, NettyTcpServer.SERVER_NAME, NettyTcpServer.SERVER_PORT);

            mNsdServer.setRegisterState(new NSDServer.IRegisterState() {
                @Override
                public void onServiceRegistered(NsdServiceInfo serviceInfo) {
                    Logger.i(TAG, "已注册服务onServiceRegistered: " + serviceInfo.toString());
                    //已经注册可停止该服务
//                    nsdServer.stopNSDServer();
                }

                @Override
                public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

                }

                @Override
                public void onServiceUnregistered(NsdServiceInfo serviceInfo) {

                }

                @Override
                public void onUnRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

                }
            });
        }
    };

    private void registerNsdServer() {
        new Thread(mNsdServerRunnable).start();
    }

    /**
     * 选择连接的Client端的channel
     *
     * @param channel
     */
    public void selectChannel(Channel channel) {
        NettyTcpServer.getInstance().selectorChannel(channel);
    }

    /**
     * 搜索并连接Netty服务端
     *
     * @param context
     */
    public void searchAndConnectServer(Context context, String uuid, NettyClientListener listener) {
        if (mNsdClient == null) {
            mNsdClient = new NsdClient(context, SERVER_NAME, new NsdClient.IServerFound() {
                @Override
                public void onServerFound(NsdServiceInfo info, int port) {
                    if (info != null) {
                        String hostAddress = info.getHost().getHostAddress();
                        Logger.d(TAG, "NSD查询到指定服务器信息ip为：" + hostAddress + ",port为：" + port);
                        //获取到指定的地址，进行Netty的连接
                        connectNettyServer(hostAddress, port, uuid, listener);

                        if (info.getServiceName().equals(SERVER_NAME)) {
                            //扫描到以后停止
                            mNsdClient.stopServiceDiscovery();
                        }
                    }
                }

                @Override
                public void onServerFail() {

                }
            });
        }
        mNsdClient.startNSDClient();
    }

    private void connectNettyServer(String serverAddress, int port, String sign, NettyClientListener listener) {
        Logger.d(TAG, "connectNettyServer");
        if (serverAddress == null || serverAddress.length() == 0) {
            Logger.e(TAG, "Netty Server的ip不能为空！");
            return;
        }
        if (mNettyTcpClient == null) {
            mNettyTcpClient = new NettyTcpClient.Builder()
                    .setHost(serverAddress)    //设置服务端地址
                    .setTcpPort(port) //设置服务端端口号
                    .setMaxReconnectTimes(5)    //设置最大重连次数
                    .setReconnectIntervalTime(5)    //设置重连间隔时间。单位：秒
                    .setSendHeartBeat(true) //设置是否发送心跳
                    .setHeartBeatInterval(120)    //设置心跳间隔时间。单位：秒
                    .setHeartBeatData(new MogoProtocolMsg(MogoProtocolMsg.HEART_DATA, 2, new byte[]{0x00, 0x00})) //设置心跳数据，可以是String类型，也可以是byte[]，以后设置的为准
                    .setSign(sign)    //设置客户端标识.(因为可能存在多个tcp连接)
                    .build();
            if (listener != null) {
                mNettyTcpClient.setListener(listener); //设置TCP监听
            }
        }

        if (!mNettyTcpClient.getConnectStatus()) {
            mNettyTcpClient.connect();//连接服务器
        } else {
            mNettyTcpClient.disconnect();
        }
    }

    public boolean getConnectStatus() {
        return mNettyTcpClient != null && mNettyTcpClient.getConnectStatus();
    }

    public String getConnServerIp() {
        if (mNettyTcpClient == null) {
            return "";
        } else {
            return mNettyTcpClient.getHost();
        }
    }

    public String getServerSn() {
        String sn = NettyTcpClient.sSERVER_SN;
        return sn;
    }

    public void sendMogoProtocolMsgToServer(MogoProtocolMsg mogoProtocolMsg, final MessageStateListener listener) {
        if (mNettyTcpClient != null) {
            mNettyTcpClient.sendMsgToServer(mogoProtocolMsg, listener);
        }
    }

    public static String bytesToHexFun(byte[] bytes, int length) {
        StringBuilder buf = new StringBuilder(length * 2);
        for (int i = 0; i < length; i++) {// 使用String的format方法进行转换
            buf.append(String.format("%02x", new Integer(bytes[i] & 0xFF)));
        }
        return buf.toString();
    }

    /**
     * 断开Netty连接
     */
    public void disconnect() {
        if (mNettyTcpClient != null) {
            mNettyTcpClient.disconnect();
        }
    }
}