package com.basic.security.utils.socket;

import android.os.SystemClock;

import com.basic.security.model.OfficeDeviceMessage;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DetectedResult;
import com.basic.security.utils.SocketUtil;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CameraYuvSocketServer {

    private static final int MAX_BUFFER = 1;

    public static List<AcceptedClient> acceptedClientList = new ArrayList<>();
    public static Lock ccceptedClientListLock = new ReentrantLock();

    public static void setCameraData(byte[] cameraData) {
        ccceptedClientListLock.lock();
        for (AcceptedClient acceptedClient : acceptedClientList) {
            acceptedClient.setCameraData(cameraData);
        }
        ccceptedClientListLock.unlock();
    }

    public static void setDetectedResult(DetectedResult detectedResult) {
        ccceptedClientListLock.lock();
        for (AcceptedClient acceptedClient : acceptedClientList) {
            acceptedClient.setDetectedResult(detectedResult);
        }
        ccceptedClientListLock.unlock();
    }

    public static class AcceptedClient extends Thread {
        Socket mSocket;

        public AcceptedClient(Socket client) {
            mSocket = client;
        }

        /////////////////////////////////////
        private final LinkedList<DetectedResult> detectedResultQueue = new LinkedList<>();
        public void setDetectedResult(DetectedResult detectedResult) {
            synchronized (detectedResultQueue) {
                if (detectedResultQueue.size() == MAX_BUFFER) {
                    detectedResultQueue.poll();
                }
                detectedResultQueue.add(detectedResult);
            }
        }
        public DetectedResult getDetectedResult() {
            DetectedResult mLastFrame = null;
            synchronized (detectedResultQueue) {
                if (detectedResultQueue.size() > 0) {
                    mLastFrame = detectedResultQueue.poll();
                }
            }
            return mLastFrame;
        }

        ///////////////////////////////
        private final LinkedList<byte[]> cameraDataQueue = new LinkedList<byte[]>();
        public void setCameraData(byte[] cameraData) {
            synchronized (cameraDataQueue) {
                if (cameraDataQueue.size() == MAX_BUFFER) {
                    cameraDataQueue.poll();
                }
                cameraDataQueue.add(cameraData);
            }
        }
        public byte[] getCameraData() {
            byte[] cameraData = null;
            synchronized (cameraDataQueue) {
                if (cameraDataQueue.size() > 0) {
                    cameraData = cameraDataQueue.poll();
                }
            }
            return cameraData;
        }

        @Override
        public void run() {
            ccceptedClientListLock.lock();
            acceptedClientList.add(this);
            ccceptedClientListLock.unlock();
            SocketUtil socketUtil = new SocketUtil();
            try {
                socketUtil.setSocket(mSocket);
                while(true) {
                    if (socketUtil.writeBitmapHeader() ) {
                        while (!Thread.currentThread().isInterrupted()) {
                            Map<String, String> map = new HashMap<>();
                            Map<String, Object> requestMap = socketUtil.readMap();
                            System.out.println("AcceptedClient.run requestMap " + requestMap);
                            boolean isRequestFrame = Constants.TRUE.equals((String)requestMap.get(OfficeDeviceMessage.requestFrame));
                            boolean isTransferVideo = Constants.TRUE.equals((String)requestMap.get(OfficeDeviceMessage.transferVideo));
                            String hasFrameData = Constants.FALSE;
                            byte[] frameData = null;
                            map.put(OfficeDeviceMessage.faceUpdateTime, null);
                            if(socketUtil.remoteIpAllowed(map)) {
                                if (isTransferVideo){
                                    if (isRequestFrame ) {
                                        frameData = getCameraData();
                                        if( frameData != null && frameData.length > 1000 ) {
                                            hasFrameData = Constants.TRUE;
                                        } else {
                                            SystemClock.sleep(500);
                                        }
                                    } else {
                                        SystemClock.sleep(500);
                                    }
                                    DetectedResult detectedResult = getDetectedResult();
                                    if (detectedResult != null) {
                                        map.put(OfficeDeviceMessage.faceUpdateTime, System.currentTimeMillis() + "");
                                    }
                                } else {
                                    DetectedResult detectedResult = getDetectedResult();
                                    if (detectedResult != null) {
                                        map.put(OfficeDeviceMessage.faceUpdateTime, System.currentTimeMillis() + "");
                                        frameData = detectedResult.originalCameraData;
                                        if (detectedResult.originalCameraDataChanged || !isRequestFrame) {
                                            hasFrameData = Constants.TRUE;
                                        }
                                    }
                                }
                            } else {
                                SystemClock.sleep(1000);
                            }
                            map.put(OfficeDeviceMessage.hasFrameData, hasFrameData);
                            System.out.println("AcceptedClient.run send " + map);
                            socketUtil.writeMap(map);
                            if (Constants.TRUE.equals(hasFrameData)) {
                                socketUtil.writeByteArray(frameData);
                            }
                            SystemClock.sleep(40);
                        }
                    } else {
                        SystemClock.sleep(2*1000);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                socketUtil.close();
            }

            ccceptedClientListLock.lock();
            acceptedClientList.remove(this);
            ccceptedClientListLock.unlock();
        }

    }

    public static void startServer() {
        new Thread(){
            @Override
            public void run() {
                ServerSocket server = null;
                try {
                    server = new ServerSocket(Constants.cameraServerPort);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                while (true) {
                    try {
                        if (server == null) {
                            break;
                        }
                        Socket client = server.accept();
                        AcceptedClient faceYuvSocketClient = new AcceptedClient(client);
                        faceYuvSocketClient.start();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        SystemClock.sleep(3000);
                    }
                }
            }
        }.start();

    }

}