package com.basic.security.utils;

import android.os.SystemClock;
import android.text.TextUtils;

import com.basic.security.base.BaseApplication;
import com.basic.security.manager.PersonManager;
import com.basic.security.manager.RemoteInDoorManager;
import com.basic.security.manager.RemoteOutdoorManager;
import com.basic.security.model.ModelAdapter;
import com.basic.security.model.Person;
import com.basic.security.model.PersonSocket;
import com.basic.security.utils.socket.BitmapListener;
import com.basic.security.utils.socket.YuvToJpgFrameBufferManager;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;

import org.apache.commons.io.IOUtils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SocketUtil {
    public ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    public Socket socket = null;
    public byte[] buffer = new byte[1];
    public DataInputStream dataInputStream;
    public DataOutputStream dataOutStream;
    public ObjectOutputStream objectOutputStream;
    public ObjectInputStream objectInputStream;
    public YuvToJpgFrameBufferManager mBufferManager;
    public byte[] imageBuff;
    public String remoteIp = "";
    public BitmapListener cameraDataListener;

    public SocketUtil() {
    }

    public static List<String> getRpcCallIp() {
        List<String> ipList = new ArrayList<>();
        if (Constants.isIndoor) {
            ipList = RemoteOutdoorManager.getOutdoorDeviceIp();
        }
        if (Constants.isOutdoor) {
            ipList = RemoteInDoorManager.getIndoorDeviceIp();
        }
        List<String> finalList = new ArrayList<>();
        for (String ip : ipList) {
            if (!TextUtils.isEmpty(ip)) {
                finalList.add(ip);
            }
        }
//        LogUtil.println("getRpcCallIp " + finalList);
        return finalList;
    }

    public static void rpcCallAsyncCommonSave(ModelAdapter modelAdapter) {
        rpcCallAsync(modelAdapter, PersonSocket.requestTypeAsyncSave);
    }

    public static void rpcCallAsyncCommonDelete(ModelAdapter modelAdapter) {
        rpcCallAsync(modelAdapter, PersonSocket.requestTypeAsyncDelete);
    }

    public static void rpcCallAsyncCommonSignal(String signalValue) {
        ModelAdapter modelAdapter = new ModelAdapter();
        modelAdapter.setString(PersonSocket.signalValue, signalValue);
        rpcCallAsync(modelAdapter, PersonSocket.signal);
    }

    public static void rpcCallAsync(ModelAdapter modelAdapter, String requestType) {
        if (!Constants.isUseSocketRpc) {
            return;
        }
        BaseApplication.getApplication().executorService.execute(() -> {
            List<String> remoteIpList = getRpcCallIp();
            for (String remoteIp : remoteIpList) {
                try {
                    SocketUtil socketUtil = new SocketUtil();
                    try {
                        byte[] modelMapByteArray = new byte[]{};
                        modelMapByteArray = ObjectUtil.toByteArray(modelAdapter.model);
                        Map<String, String> requestMap = new HashMap<>();
                        requestMap.put(PersonSocket.modelMapByteArrayLength, modelMapByteArray.length + "");
                        requestMap.put(PersonSocket.requestType, requestType);
                        socketUtil.openSocket(remoteIp, Constants.personServerPort);
                        socketUtil.writeMap(requestMap);
                        if (modelMapByteArray.length > 0) {
                            socketUtil.writeByteArray(modelMapByteArray);
                        }
                        Map<String, String> responseMap = socketUtil.readJsonAsMap();
//                        System1.out.println("SocketUtil.rpcCallAsync " + responseMap + " " + requestType + " remoteIp=" + remoteIp + " " + Constants.personServerPort);
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        socketUtil.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public static void rpcCallSaveHintSignUp(ModelAdapter hintSignUpMassage) {
        rpcCallAsyncCommonSave(hintSignUpMassage);
    }

    public static void rpcCallSaveHintDoorAccess(ModelAdapter hintDoorAccess) {
        rpcCallAsyncCommonSave(hintDoorAccess);
    }

    public static void rpcCallSaveHintRecognize(ModelAdapter hintRecognize) {
        rpcCallAsyncCommonSave(hintRecognize);
    }

    public static void rpcCallSaveTimeRule(ModelAdapter timeRule) {
        rpcCallAsyncCommonSave(timeRule);
    }

    public static void rpcCallSaveVisit(ModelAdapter visit) {
        rpcCallAsyncCommonSave(visit);
    }

    public static void rpcCallInitTreeNodeList() {
        rpcCallAsyncCommonSignal(PersonSocket.signalInitTreeNodeList);
    }

    public static void rpcCallDeleteOrg(ModelAdapter org) {
        rpcCallAsyncCommonDelete(org);
    }

    public static void rpcCallSaveOrg(ModelAdapter org) {
        rpcCallAsyncCommonSave(org);
    }

    public static void rpcCallSendIdCard(IdCard idcard) {
        ModelAdapter modelAdapter = new ModelAdapter();
        modelAdapter.model = idcard.toMap();
        rpcCallAsyncCommonSave(modelAdapter);
    }

    public static void rpcCallSavePersonIdentity(ModelAdapter personIdentity) {
        rpcCallAsyncCommonSave(personIdentity);
    }

    public static void rpcCallSavePerson(ModelAdapter person) {
        byte[] personArray = new byte[]{};
        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);
        }
        rpcCallAsyncCommonSave(person);
    }

    public static void rpcCallDeletePersonIdentity(ModelAdapter personIdentity) {
        rpcCallAsyncCommonDelete(personIdentity);
    }

    public static void rpcCallDeletePerson(ModelAdapter person) {
        rpcCallAsyncCommonDelete(person);
    }

    public static ModelAdapter rpcCallFindPersonById(String personId) {
        List<String> remoteIpList = getRpcCallIp();
        for (String remoteIp : remoteIpList) {
            SocketUtil socketUtil = new SocketUtil();
            try {
                Map<String, String> requestMap = new HashMap<>();
                requestMap.put(Person.id, personId);
                requestMap.put(PersonSocket.requestType, PersonSocket.findPersonById);
                socketUtil.openSocket(remoteIp, Constants.personServerPort);
                socketUtil.writeMap(requestMap);
                Map<String, String> responseMap = socketUtil.readJsonAsMap();
                int modelMapByteArrayLength = Integer.parseInt(responseMap.get(PersonSocket.modelMapByteArrayLength));
                if (modelMapByteArrayLength > 0) {
                    byte[] personByteArray = new byte[modelMapByteArrayLength];
                    socketUtil.readFullByteArray(personByteArray);
                    Map<String, Object> personModel = (Map<String, Object>) ObjectUtil.toObject(personByteArray);//SerializationUtils.deserialize(personByteArray);
                    if (personModel != null) {
//                    System1.out.println("SocketUtil.rpcCallFindPersonById " + personModel);
                        ModelAdapter person = new ModelAdapter();
                        person.model = personModel;
                        byte[] camera_image_path_byte_array = (byte[]) person.model.get(PersonSocket.camera_image_path_byte_array);
                        if (camera_image_path_byte_array != null && camera_image_path_byte_array.length > 0) {
                            person.setBlob(Person.camera_image_path, camera_image_path_byte_array);
                        }
                        PersonManager.savePerson(person);
                        return person;
                    }
                } else {
//                System1.out.println("SocketUtil.rpcCallFindPersonById");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                socketUtil.close();
            }
        }
        return null;
    }

    public static Map<String, String> rpcCall(String ip, int port, Map<String, String> requestMap) {
        SocketUtil socketUtil = new SocketUtil();
        try {
            socketUtil.openSocket(ip, port);
            socketUtil.writeMap(requestMap);
            return socketUtil.readJsonAsMap();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            socketUtil.close();
        }
        return null;
    }

    public static Map<String, String> rpcCallDownload(String ip, int port, String camera_image_path) {
        SocketUtil socketUtil = new SocketUtil();
        try {
            socketUtil.openSocket(ip, port);
            Map<String, String> requestMap = new HashMap<>();
            requestMap.put(Person.camera_image_path, camera_image_path);
            socketUtil.writeMap(requestMap);
            Map<String, Object> responseMap = socketUtil.readMap();
            if (Constants.TRUE.equals(responseMap.get(Constants.SUCCESS))) {
                int length = Integer.parseInt(responseMap.get(Constants.LENGTH) + "");
                byte[] fileBuffer = new byte[length];
                socketUtil.readFullByteArray(fileBuffer);
                FileWriter fileWriter = new FileWriter(camera_image_path);
                IOUtils.write(fileBuffer, fileWriter);
                fileWriter.flush();
                fileWriter.close();
                System1.out.println("SocketUtil.rpcCallDownload camera_image_path=" + camera_image_path);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            socketUtil.close();
        }
        return null;
    }

    public static void rpcCallAsyncDeleteBusinessRule(ModelAdapter business) {
        rpcCallAsyncCommonDelete(business);
    }

    public static void rpcCallSaveBusinessRule(ModelAdapter business) {
        rpcCallAsyncCommonSave(business);
    }

    public static void rpcCallDeleteTimeRule(ModelAdapter timeRule) {
        rpcCallAsyncCommonDelete(timeRule);
    }

    public Map<String, String> readJsonAsMap() throws Exception {
        String json;
        int len;
        while ((len = dataInputStream.read(buffer)) != -1) {
            for (int i = 0; i < len; i++) {
                if (buffer[i] == '\0') {
                    Map<String, String> messageMap = new HashMap<>();
                    try {
                        byte[] jsonByteArray = byteArrayOutputStream.toByteArray();
                        byteArrayOutputStream.reset();
                        json = new String(jsonByteArray, 0, jsonByteArray.length);
                        json = json.substring(0, json.lastIndexOf("}") + 1);
                        if (json.length() > 3) {
                            JsonParser parser = new JsonParser();
                            boolean isJSON = true;
                            JsonElement element = null;
                            try {
                                element = parser.parse(json);
                            } catch (JsonParseException e) {
                                System1.out.println("exception: " + e);
                                isJSON = false;
                            }
                            if (isJSON && element != null) {
                                JsonObject obj = element.getAsJsonObject();
                                for (Map.Entry<String, JsonElement> entry : obj.entrySet()) {
                                    if (!(entry.getValue() instanceof JsonNull)) {
                                        messageMap.put(entry.getKey(), entry.getValue().getAsString());
                                    }
                                }
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return messageMap;
                } else {
                    byteArrayOutputStream.write(buffer[i]);
                }
            }
        }
        throw new RuntimeException("inputStream.read(buffer) == -1");
    }

    public void close() {
        try {
            if (socket != null) {
                socket.close();
                socket = null;
            }
            if (byteArrayOutputStream != null) {
                byteArrayOutputStream.close();
                byteArrayOutputStream = null;
            }
            if (mBufferManager != null) {
                mBufferManager.close();
                mBufferManager = null;
            }
        } catch (IOException e) {
        }
    }

    public void setSocket(Socket socket) throws Exception {
        this.socket = socket;
        this.remoteIp = (((InetSocketAddress) socket.getRemoteSocketAddress()).getAddress()).toString().replace("/", "");
        BufferedInputStream inputStream = new BufferedInputStream(socket.getInputStream());
        BufferedOutputStream outputStream = new BufferedOutputStream(socket.getOutputStream());
        dataInputStream = new DataInputStream(socket.getInputStream());
        dataOutStream = new DataOutputStream(outputStream);
        if (byteArrayOutputStream == null) {
            byteArrayOutputStream = new ByteArrayOutputStream();
        }
        byteArrayOutputStream.reset();
    }

    public void openSocket(String ip, int port) throws Exception {
        close();
        SystemClock.sleep(Constants.reconnectInMilliSeconds);
        socket = new Socket();
        socket.connect(new InetSocketAddress(ip, port), 10000);
        this.setSocket(socket);
    }

    public void writeMessage(String key, String value) throws Exception {
        JsonObject jsonObj = new JsonObject();
        jsonObj.addProperty(key, value);
        dataOutStream.write(jsonObj.toString().getBytes());
        dataOutStream.write('\0');
        dataOutStream.flush();
    }

    public void writeMessage(Map<String, String> keyValues) throws Exception {
        JsonObject jsonObj = new JsonObject();
        for (Map.Entry<String, String> entry : keyValues.entrySet()) {
            jsonObj.addProperty(entry.getKey(), entry.getValue());
        }
        dataOutStream.write(jsonObj.toString().getBytes());
        dataOutStream.write('\0');
        dataOutStream.flush();
    }

    public void writeByteArray(byte[] byteArray) throws Exception {
        if (byteArray != null) {
            dataOutStream.write(byteArray);
            dataOutStream.flush();
        }
    }

    public void readFullByteArray(byte[] imageBuff) throws Exception {
        dataInputStream.readFully(imageBuff, 0, imageBuff.length);
    }

    public void readFullByteArray(byte[] imageBuff, int length) throws Exception {
        dataInputStream.readFully(imageBuff, 0, length);
    }

    public void readFrameInfo() throws Exception {
        Map<String, String> messageMap = this.readJsonAsMap();
        int length = Integer.parseInt(messageMap.get("length"));
        int width = Integer.parseInt(messageMap.get("width"));
        int height = Integer.parseInt(messageMap.get("height"));
        imageBuff = new byte[length];
        mBufferManager = new YuvToJpgFrameBufferManager(length, width, height);
    }

    public boolean readBitmapHeader(Map<String, String> frameInfo) {
        boolean success = frameInfo.get(Constants.SUCCESS).equals(Constants.TRUE);
        if (success) {
            int length = Integer.parseInt(frameInfo.get("length"));
            int width = Integer.parseInt(frameInfo.get("width"));
            int height = Integer.parseInt(frameInfo.get("height"));
            imageBuff = new byte[length];
            mBufferManager = new YuvToJpgFrameBufferManager(length, width, height);
        }
        return success;
    }

    public boolean readBitmapHeader() throws Exception {
        return readBitmapHeader((Map<String, String>) this.readObject());
    }

    public void setBitmapListener(BitmapListener cameraDataListener) {
        mBufferManager.setOnDataListener(cameraDataListener);
        this.cameraDataListener = cameraDataListener;
    }

    public Object readObject() throws Exception {
        return readJsonAsMap();
    }

    public boolean remoteIpAllowed() {
        return true;
    }

    public boolean remoteIpAllowed(Map<String, String> map) {
        if (remoteIpAllowed()) {
            map.put(Constants.SUCCESS, Constants.TRUE);
        } else {
            map.put(Constants.SUCCESS, Constants.FALSE);
        }
        return true;
    }

    public boolean writeBitmapHeader() throws Exception {
        boolean success;
        Map<String, String> map = new HashMap<>();
        if (remoteIpAllowed()) {
            map.put(Constants.SUCCESS, Constants.TRUE);
            map.put("type", "data");
            map.put("length", "460800");
            map.put("width", "640");
            map.put("height", "480");
            map.put("rotation", "270");
            success = true;
        } else {
            map.put(Constants.SUCCESS, Constants.FALSE);
            success = false;
        }
        writeMessage(map);
        return success;
    }

    public void writeMap(Map<String, String> map) throws Exception {
        writeMessage(map);
    }

    public Map<String, Object> readMap() throws Exception {
        return (Map<String, Object>) readObject();
    }

    public void writeResponseSuccess() throws Exception {
        Map<String, String> responseMap = new HashMap<>();
        responseMap.put(Constants.SUCCESS, Constants.TRUE);
        writeMap(responseMap);
    }

    public ModelAdapter readModelAdapterMap(Map<String, String> requestMap) throws Exception {
        int modelMapByteArrayLength = Integer.parseInt(requestMap.get(PersonSocket.modelMapByteArrayLength));
        if (modelMapByteArrayLength > 0) {
            byte[] personByteArray = new byte[modelMapByteArrayLength];
            readFullByteArray(personByteArray);
            Map<String, Object> modelMap = (Map<String, Object>) ObjectUtil.toObject(personByteArray);
            if (modelMap != null) {
                ModelAdapter modelAdapter = new ModelAdapter();
                modelAdapter.model = modelMap;
                return modelAdapter;
            }
        }
        return null;
    }
}