package com.qnbar.smc.service;

import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;
import com.gimi.common.cinema.model.MessageEvent;
import com.gimi.common.cinema.model.RoomInfo;
import com.gimi.common.cinema.utils.ActivityCollector;
import com.gimi.common.cinema.utils.CToast;
import com.gimi.common.cinema.utils.LogUtils;
import com.gimi.common.cinema.utils.NetStatusUtils;
import com.gimi.common.cinema.utils.SystemUtils;
import com.gimi.common.cinema.utils.Utils;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.qnbar.smc.utils.LightOperationUtils;
import com.xgimi.gimicinema.activity.AdsPreVideoPlayerActivity;
import com.xgimi.gimicinema.activity.MainActivity;
import com.xgimi.gimicinema.activity.QrCodeShowActivity;
import com.xgimi.gimicinema.activity.SimpleAdsPlayer2;
import com.xgimi.gimicinema.application.FangTangApplication;
import com.xgimi.gimicinema.poll.PollingUtils;
import com.xgimi.gimicinema.service.CountService;
import com.xgimi.smartscreen.encrypt.AuthCode;
import org.greenrobot.eventbus.EventBus;

import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import static com.qnbar.smc.service.SocketService.JUST_OPEN_DOOR;
import static com.qnbar.smc.service.SocketService.USER_OPEN_DOOR;
import static com.qnbar.smc.service.SocketService.USER_OPEN_DOOR_AND_GET_MOVIE;

public class SocketService1 extends BaseService {
    private static final String TAG = "BackService1";
    private static final long HEART_BEAT_RATE = 2 * 1000;
    private final long READ_THREAD_DEFAULT_SLEEP_MTIME = 100;

    //    public static final int USER_OPEN_DOOR_AND_GET_MOVIE = 1703;
    /*
    * 10001 //服务器发送了命令(带命令的返回消息),这个一般是服务器主动发消息的时候code为这个值
      10002 //连接(认证)失败
      10003 //还未注册连接就进行认证
      10004 //终端编号未传
      10005 //心跳异常,没有找到房间连接信息
      10006 //心跳异常,连接标识符不一致
      10007 //收到未知命令
      10008 //收到无法解析的消息
      10009 //已经认证过了,不允许再认证
      10010 //room_sn 已连接,不能再连接
      9997  //心跳成功
      9998  //请求认证被服务器接受了,服务器返回了认证码
      9999  //认证成功,可以开始心跳了
    */
    private static final int HEART_BEAT_SUCCESS = 9997;
    private static final int RETURN_VERIFY_CODE = 9998;
    private static final int VERIFY_SUCCESS = 9999;
    private static final int SUCCESS_MESSAGE = 10000;
    private static final int CONTAIN_MESSAGE = 10001;
    private static final int AUTHENTICATION_FAILED = 10002; //连接(认证)失败
    private static final int CONNECTION_BEFORE_AUTHENTICATION = 10003;//还未注册连接就进行认证
    private static final int NOT_SEND_ROOM_SN = 10004;//终端编号未传
    private static final int HEART_BEAR_ERROR = 10005; //心跳异常,没有找到房间连接信息
    private static final int HEART_BEAT_ERROR_SYMBOL = 10006;//心跳异常,连接标识符不一致
    private static final int ROOM_SN_CONNECTED = 10010;//room_sn 已连接,不能再连接
    private static final int OPEN_DOOR = 50001;//开门命令
    private static final int CLEAN_OVER = 50002;//

    private static final int ROOM_HAS_REGISTERED = 1001;
    private static final int ROOM_NOT_EXIST_M = 1002;
    private static final int HEAT_BEAT_RTN = 1003;

    //    online
    public static final String SERVER_HOST_ONLINE = "conn.ft.qnbar.com";// "192.168.1.21";//
    public static final int SERVER_PORT_ONLINE = 8899;

    //    develop
    public static final String SERVER_HOST_DEVELOP = "10.10.4.6";// "192.168.1.21";//
    public static final int SERVER_PORT_DEVELOP = 9501;
    //    test
    public static final String SERVER_HOST = "10.10.4.6";// "192.168.1.21";//
    public static final int SERVER_PORT = 8899;

    private String serverHost = SERVER_HOST;
    private int serverPort = SERVER_PORT;


    public static final String END_SYMBOL = "\\r\\n\\r\\n";//心跳包内容
    //    public String testRoomSn = "R170413034374";
    public String testRoomSn = "c";

    //    private ReadThread mReadThread;
    private Gson gson = new Gson();

    //    private WeakReference<Socket> mSocket;
    private Socket socket = null;
    StringBuilder readingMsg = new StringBuilder();

    // For heart Beat
    private Handler mHandler = new Handler();

    AtomicBoolean sendRegister = new AtomicBoolean(false);
    AtomicInteger heartBeatErrorCount = new AtomicInteger(0);

    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            mHandler.postDelayed(this, HEART_BEAT_RATE);
            //就发送一个HEART_BEAT_STRING过去 如果发送失败，就重新初始化一个socket
            final String s = new Gson().toJson(
                    new SocketSendMsg().contractHeartBeatMsg(testRoomSn));
            boolean isSuccess = sendMsg(s + END_SYMBOL);
            if (!isSuccess) {
                LogUtils.i(TAG, "send heart beat error restart");
            }
        }
    };
    int mainChargeCount = 0;
    private Runnable startMainRunnable = new Runnable() {
        @Override
        public void run() {
            if (ActivityCollector.getActivity(MainActivity.class) == null) {
                LogUtils.i(TAG, "do start main activity");
                Intent intent = new Intent(context, MainActivity.class);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(intent);
            } else {
                LogUtils.i(TAG, "already start main activity");
            }
        }
    };

    private Context context = this;

    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        LogUtils.i(TAG, "onCreate");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        LogUtils.i(TAG, "onStartCommand");
        int ftTest = Utils.getInt(this, "ft-test", 0);
        switch (ftTest) {
            case 0:
                serverHost = SERVER_HOST_ONLINE;
                serverPort = SERVER_PORT_ONLINE;
                break;
            case 1:
                serverHost = SERVER_HOST_DEVELOP;
                serverPort = SERVER_PORT_DEVELOP;
                break;
            case 2:
                serverHost = SERVER_HOST;
                serverPort = SERVER_PORT;
                break;
        }

        String roomInfoStr = Utils.getString(this, "room-info");
        if (TextUtils.isEmpty(roomInfoStr)) {
            LogUtils.i("room-info", "room info not exist");
            Toast.makeText(this, "没有获取到房间信息，请查看后台配置", Toast.LENGTH_SHORT).show();
            return super.onStartCommand(intent, flags, startId);
        }

        LogUtils.i("room-info", "room info not null");
        RoomInfo roomInfo = null;
        try {
            roomInfo = gson.fromJson(roomInfoStr, RoomInfo.class);
            LogUtils.i("room-info", "room info room_sn update");
            testRoomSn = roomInfo.getData().getRoom_sn();
        } catch (JsonSyntaxException e) {
            LogUtils.i("room-info", "room gson parse exception return");
            Toast.makeText(this, "房间信息配置出错，请重新进入应用获取", Toast.LENGTH_SHORT).show();
            e.printStackTrace();
            return super.onStartCommand(intent, flags, startId);
        }
        new InitSocketThread().start();
        new ReadThread().start();
        return START_STICKY;
    }

    ///begin socket operation
    private synchronized void initSocket() throws IOException {//初始化Socket
        if (socket != null && socket.isConnected()) {
            return;
        }
        boolean networkConnected = NetStatusUtils.isNetworkConnected(context);
        boolean availableByPing = NetStatusUtils.isAvailableByPing("www.baidu.com");
        boolean availableByPing1 = NetStatusUtils.isAvailableByPing(serverHost);
        boolean availableByPing2 = NetStatusUtils.isAvailableByPing("192.168.200.241");
        LogUtils.i(TAG, "initsocket serverHost:serverPort:" + serverHost + ":" + serverPort);
        LogUtils.i(TAG, "networkConnected:" + networkConnected + ":baidu:" + availableByPing + ",serverHost:" + availableByPing1 + ",serverIp:" + availableByPing2);
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                CToast.makeText(context, "开始连接服务器", 10 * 1000).show();
            }
        });
        socket = new Socket(serverHost, serverPort);
        socket.setSoTimeout(100);
        readingMsg.setLength(0);
    }


    private synchronized boolean sendMsg(String msg) {
        if (socket == null || !socket.isConnected()) {
            return false;
        }
        if (!msg.contains("20025")) {
            LogUtils.i(TAG, "send msg:" + msg);
        } else {
            if (heartBeatErrorCount.getAndIncrement() > 3) {
//            if (heartBeatErrorCount.getAndDecrement() >= 0) {
                LogUtils.i(TAG, "heartBeatErrorCount:" + heartBeatErrorCount.get());
                clearConnect();
                return false;
            }
            LogUtils.d(TAG, "send heart beat msg:" + msg);
        }
        Socket soc = socket;
        try {
            if (!soc.isClosed() && !soc.isOutputShutdown()) {
                OutputStream os = soc.getOutputStream();
                os.write(msg.getBytes());
                os.flush();
            } else {
                return false;
            }
        } catch (IOException e) {
            LogUtils.e(TAG, "error" + e.getMessage());
            e.printStackTrace();
            clearConnect();
            return false;
        }
        return true;
    }

    private synchronized void releaseLastSocket() {
        try {
            if (null != socket) {
                socket.close();
            }
        } catch (IOException e) {
            LogUtils.e(TAG, "error" + e.getMessage());
            e.printStackTrace();
        } finally {
            socket = null;
            readingMsg.setLength(0);
        }
    }

    private synchronized boolean recvMsg(StringBuilder msg) {
        if (null == socket || !socket.isConnected()) {
            return false;
        }
        try {
            InputStream is = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int length = 0;
            while (!socket.isClosed()
                    && !socket.isInputShutdown()
                    && ((length = is.read(buffer)) > 0)
                    ) {
                String tmp = new String(Arrays.copyOf(buffer, length));
                readingMsg.append(tmp);
                int pos = readingMsg.indexOf(END_SYMBOL);
                if (pos != -1) {
                    msg.setLength(0);
                    msg.append(readingMsg.substring(0, pos));
                    readingMsg.delete(0, pos + END_SYMBOL.length());
                    return true;
                }
            }
        } catch (InterruptedIOException e) {
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            LogUtils.e(TAG, e.getMessage());
            clearConnect();
            return false;
        }
        return false;
    }

    private synchronized void clearConnect() {
        LogUtils.i(TAG, "clearConnect");
        mHandler.removeCallbacks(heartBeatRunnable);
        sendRegister.set(false);
        heartBeatErrorCount.set(0);
        releaseLastSocket();
    }
    ///end socket operation

    class InitSocketThread extends Thread {
        @Override
        public void run() {
            while (!isInterrupted()) {
                try {
                    initSocket();
                } catch (IOException e) {
                    e.printStackTrace();
                    LogUtils.e(TAG, "init socket thread error,restart again after " + HEART_BEAT_RATE / 1000 + " seconds");
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    LogUtils.e(TAG, "error" + e1.getMessage());
                    e1.printStackTrace();
                }
            }
        }
    }

    // Thread to read content from Socket
    class ReadThread extends Thread {
        private long sleepTime = 0;

        @Override
        public void run() {
            StringBuilder message = new StringBuilder();
            while (!isInterrupted()) {
                if (!sendRegister.get()) {
                    SocketSendMsg ssm = new SocketSendMsg().contractRegisterMsg(testRoomSn);
                    String msg = gson.toJson(ssm) + END_SYMBOL;
                    LogUtils.i(TAG, "send register mes:" + msg);
                    if (!sendMsg(msg)) {
                        try {
                            Thread.sleep(READ_THREAD_DEFAULT_SLEEP_MTIME);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        continue;
                    }
                    sendRegister.set(true);
                }

                LogUtils.d(TAG, "begin to recv msg");

                sleepTime = READ_THREAD_DEFAULT_SLEEP_MTIME;
                while (recvMsg(message)) {
                    sleepTime = READ_THREAD_DEFAULT_SLEEP_MTIME;

                    LogUtils.d(TAG, "recv msg:" + message);
                    SocketResponse socketResponse;
                    try {
                        socketResponse = gson.fromJson(message.toString(),
                                SocketResponse.class);
                        if (socketResponse.getCode() != HEART_BEAT_SUCCESS) {
                            LogUtils.i(TAG, "recv msg:" + message);
                        }
                    } catch (JsonSyntaxException e) {
                        LogUtils.e(TAG, "invalid msg:", message + e.getMessage());
                        e.printStackTrace();
                        clearConnect();
                        break;
                    }
                    switch (socketResponse.getCode()) {
                        case SUCCESS_MESSAGE:
                            heartBeatErrorCount.set(0);
                            Log.d(TAG, "SUCCESS_MESSAGE");
                            break;
                        case VERIFY_SUCCESS:
                            mHandler.post(heartBeatRunnable);
                            LogUtils.i(TAG, "verify success start heart beat");
                            break;
                        case HEART_BEAT_SUCCESS:
                            LogUtils.d(TAG, "HEART_BEAT_SUCCESS,MainActivity Launched:" + ActivityCollector.isActivityExist(MainActivity.class));
                            heartBeatErrorCount.set(0);
                            //每成功5次心跳判定是否启动main activity
                            if (++mainChargeCount == 5) {
                                mainChargeCount = 0;
                                if (heartBeatErrorCount.get() < 3) {
                                    LogUtils.i(TAG, "heart beat regular");
                                }
                                if (!ActivityCollector.isActivityExist(MainActivity.class)) {
                                    LogUtils.i(TAG, "charge start main activity");
                                    mHandler.postDelayed(startMainRunnable, 3 * 1000);
                                }
                            }
                            break;
                        case HEART_BEAT_ERROR_SYMBOL:
                        case ROOM_SN_CONNECTED:
                            String msg1 = socketResponse.getCode() == HEART_BEAT_ERROR_SYMBOL ? "HEART_BEAT_ERROR_SYMBOL" : "ROOM_SN_CONNECTED";
                            LogUtils.e(TAG, msg1);
                            clearConnect();
                            break;
                        case RETURN_VERIFY_CODE:
                            LogUtils.i(TAG, "RETURN_VERIFY_CODE");
                            if (!TextUtils.isEmpty(socketResponse.getData().getVerify())) {
                                String verifyMsg = AuthCode.getDecodeStr(socketResponse.getData().getVerify());
                                SocketSendMsg ssm = new SocketSendMsg().contractVerifyMsg(testRoomSn, verifyMsg);
                                String msg = gson.toJson(ssm) + END_SYMBOL;
                                sendMsg(msg);
                            }
                            break;
                        case CONTAIN_MESSAGE:
                            heartBeatErrorCount.set(0);
                            LogUtils.i(TAG, "CONTAIN_MESSAGE");
                            if (socketResponse.getData() != null) {
                                if (socketResponse.getCmd() == OPEN_DOOR) {
                                    switch (socketResponse.getData().getUser()) {
                                        //10用户,20管理员,默认值为0
                                        case 10:
                                            new SystemUtils().openFtLed(context.getApplicationContext());
                                            if (TextUtils.isEmpty(((FangTangApplication) getApplication()).getCurrentPlayUrl())) {
                                                LightOperationUtils.open();
                                                LightOperationUtils.setLightValue(Utils.getInt(context, "brightness", 50));
                                            }
                                            sendMessage(QrCodeShowActivity.KILL_SELF, "finish the QR CODE activity when new user come in");
                                            if (socketResponse.getData().getFirst() == 1) {
                                                sendMessage(USER_OPEN_DOOR_AND_GET_MOVIE, "user first open the door");
                                            } else {
                                                sendMessage(USER_OPEN_DOOR, "user open the door");
                                            }
                                            break;
                                        case 20:
                                            LogUtils.i(TAG, "admin open the door,del the log");
                                            LogUtils.delLog();
                                            if (TextUtils.isEmpty(((FangTangApplication) getApplication()).getCurrentPlayUrl())) {
                                                LogUtils.i("LightOperationUtils", "admin open light");
                                                LightOperationUtils.open();
                                                LightOperationUtils.setLightValue(Utils.getInt(context, "brightness", 50));
                                            }
                                            sendMessage(JUST_OPEN_DOOR, "administrator open the door");
                                            break;
                                        case 0:
                                            sendMessage(JUST_OPEN_DOOR, "get zero none user or administrator open the door");
                                            break;
                                        default:
                                            sendMessage(JUST_OPEN_DOOR, "none user or administrator open the door");
                                            break;
                                    }
                                } else if (socketResponse.getCmd() == CLEAN_OVER) {
                                    LogUtils.i("LightOperationUtils", "admin clean over close light");
                                    LightOperationUtils.setLightValue(5);
                                    LightOperationUtils.close();
                                    new SystemUtils().closeFtLed(context.getApplicationContext());
                                    sendMessage(QrCodeShowActivity.KILL_SELF, "finish the QR CODE activity when clean over");
                                    if (ActivityCollector.isActivityExist(SimpleAdsPlayer2.class)) {
                                        ActivityCollector.getActivity(SimpleAdsPlayer2.class).finish();
                                    }
                                    if (ActivityCollector.isActivityExist(AdsPreVideoPlayerActivity.class)) {
                                        ActivityCollector.getActivity(AdsPreVideoPlayerActivity.class).finish();
                                    }
                                    if (ActivityCollector.isActivityExist(QrCodeShowActivity.class)) {
                                        ActivityCollector.getActivity(QrCodeShowActivity.class).finish();
                                    }
                                    try {
                                        PollingUtils.stopPollingService(context, CountService.class, CountService.STATUS_ACTION);
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                            break;
                        default:
                            clearConnect();
                            LogUtils.i(TAG, "default msg clearConnect:" + socketResponse.toString());
                    }
                }
                try {
                    Thread.sleep(sleepTime);
                } catch (InterruptedException e) {
                    continue;
                }
            }
        }
    }

    private void sendMessage(int type, String msg) {
        MessageEvent messageEvent = new MessageEvent();
        messageEvent.setEventId(type);
        messageEvent.setMessage(msg);
        EventBus.getDefault().post(messageEvent);
    }

    @Override
    public void onDestroy() {
        LogUtils.i(TAG, "socket service destroy");
        super.onDestroy();
    }
}