package com.basic.security.utils.socket.server;

import android.os.SystemClock;

import com.basic.security.base.BaseApplication;
import com.basic.security.manager.BaseManager;
import com.basic.security.manager.FeatureManager;
import com.basic.security.manager.GuestManager;
import com.basic.security.manager.OrgManager;
import com.basic.security.manager.PersonManager;
import com.basic.security.model.IdCard;
import com.basic.security.model.IdCardMessage;
import com.basic.security.model.ModelAdapter;
import com.basic.security.model.Person;
import com.basic.security.model.PersonSocket;
import com.basic.security.model.Sync;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DetectedResult;
import com.basic.security.utils.ObjectUtil;
import com.basic.security.utils.SocketUtil;

import org.apache.commons.io.IOUtils;

import java.io.FileOutputStream;
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 TableRowReceiveSocketServer {
    private static final int MAX_BUFFER = 1;
    public static List<TableRowReceiveSocketServer.PersonAcceptedClient> acceptedClientList = new ArrayList<>();
    public static Lock acceptedClientListLock = new ReentrantLock();
    public static boolean startServer = false;
    static long lastSetDetectedResult = 0;

    public static void startServer() {
        if (startServer) {
            return;
        }
        startServer = true;
        BaseApplication.getApplication().executorService.execute(() -> {
            ServerSocket server = null;
            try {
                server = new ServerSocket(Constants.personServerPort);
            } catch (Exception e) {
                e.printStackTrace();
            }
            while (true) {
                try {
                    if (server == null) {
                        break;
                    }
                    Socket client = server.accept();
                    PersonAcceptedClient guestAcceptedSocketClient = new PersonAcceptedClient(client);
                    guestAcceptedSocketClient.start();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    SystemClock.sleep(1000);
                }
            }
        });
    }

    public static class PersonAcceptedClient extends Thread {
        private final LinkedList<DetectedResult> detectedResultQueue = new LinkedList<>();
        private final LinkedList<byte[]> cameraDataQueue = new LinkedList<byte[]>();
        Socket mSocket;

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

        public void run() {
            SocketUtil socketUtil = new SocketUtil();
            try {
                socketUtil.setSocket(mSocket);
                Map<String, String> requestMap = socketUtil.readJsonAsMap();
                String requestType = requestMap.get(PersonSocket.requestType);
                if (PersonSocket.requestTypeAsyncSave.equals(requestType)) {
                    ModelAdapter modelAdapter = socketUtil.readModelAdapterMap(requestMap);
                    String table = modelAdapter.getString(Constants.TABLE);
                    if (Person.tableName.equals(table)) {
                        byte[] camera_image_path_byte_array = (byte[]) modelAdapter.model.get(PersonSocket.camera_image_path_byte_array);
                        if (camera_image_path_byte_array != null && camera_image_path_byte_array.length > 0) {
                            modelAdapter.setBlob(Person.camera_image_path, camera_image_path_byte_array);
                        }
                        GuestManager.updateGuestName(modelAdapter);
                        FeatureManager.addFeature(modelAdapter.getString(Person.id), modelAdapter.getBlob(Person.camera_image_feature));
                    }
//                    System1.out.println("PersonAcceptedClient.run 1 " + modelAdapter);
                    if (IdCard.tableName.equals(table)) {
                        byte[] jpgData = (byte[]) modelAdapter.model.get(IdCardMessage.jpgData);
                        if (jpgData != null && jpgData.length > 0) {
                            try {
                                String idCardPath = Constants.attachmentPath + modelAdapter.getString(IdCard.card_number) + ".jpg";
                                System1.out.println("PersonAcceptedClient.run idCardPath=" + idCardPath);
                                IOUtils.write(jpgData, new FileOutputStream(idCardPath));
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    modelAdapter.setString(Sync.needSync, Constants.FALSE);
                    BaseManager.save(modelAdapter);
                    socketUtil.writeResponseSuccess();
                }
                if (PersonSocket.requestTypeAsyncDelete.equals(requestType)) {
                    ModelAdapter modelAdapter = socketUtil.readModelAdapterMap(requestMap);
                    String table = modelAdapter.getString(Constants.TABLE);
                    if (Person.tableName.equals(table)) {
                        String personId = modelAdapter.getString(Person.id);
                        FeatureManager.removeFeature(personId);
                        if (Constants.isIndoor) {
                            GuestManager.removePersonId(personId);
                        }
                    }
                    modelAdapter.setString(Sync.needSync, Constants.FALSE);
                    if (Person.tableName.equals(table) && !Constants.deletePersonPhysical) {
                        BaseManager.deleteWithDelFlag(modelAdapter);
                    } else {
                        BaseManager.deletePhysically(modelAdapter);
                    }
                    socketUtil.writeResponseSuccess();
                }
                if (PersonSocket.signal.equals(requestType)) {
                    ModelAdapter modelAdapter = socketUtil.readModelAdapterMap(requestMap);
                    String signalValue = modelAdapter.getString(PersonSocket.signalValue);
                    if (PersonSocket.signalInitTreeNodeList.equals(signalValue)) {
                        OrgManager.initTreeNodeList();
                    }
                    modelAdapter.setString(Sync.needSync, Constants.FALSE);
                    socketUtil.writeResponseSuccess();
                }
                if (PersonSocket.findPersonById.equals(requestType)) {
                    String personId = requestMap.get(Person.id);
                    ModelAdapter person = PersonManager.findPersonById(personId);
                    byte[] personByteArray = new byte[]{};
                    if (person != null) {
                        byte[] camera_image_path = person.getBlob(Person.camera_image_path);
                        if (camera_image_path != null && camera_image_path.length > 0) {
                            person.model.put(PersonSocket.camera_image_path_byte_array, camera_image_path);
                        }
                        personByteArray = ObjectUtil.toByteArray(person.model);//SerializationUtils.serialize(person);
                        Map<String, Object> newPerson = (Map<String, Object>) ObjectUtil.toObject(personByteArray);//SerializationUtils.deserialize(personByteArray);
//                        System1.out.println("PersonAcceptedClient.run findPersonById=" + newPerson);
                    }
                    Map<String, String> responseMap = new HashMap<>();
                    responseMap.put(PersonSocket.modelMapByteArrayLength, personByteArray.length + "");
                    socketUtil.writeMap(responseMap);
                    if (personByteArray.length > 0) {
                        socketUtil.writeByteArray(personByteArray);
                    }
                }
                SystemClock.sleep(4 * 1000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                socketUtil.close();
            }
        }
    }
}