package com.basic.security.utils;

import android.os.SystemClock;

import com.basic.security.manager.OfficeDeviceManager;
import com.basic.security.utils.yuv.BitmapListener;
import com.basic.security.utils.yuv.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 java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

public class SocketUtil {

    public ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    public Socket socket = null;
    public byte[] buffer = new byte[1];
    //    public BufferedInputStream inputStream;
//    public BufferedOutputStream outputStream;
    public DataInputStream dataInputStream;
    public DataOutputStream dataOutStream;
    public ObjectOutputStream objectOutputStream;
    public ObjectInputStream objectInputStream;
    public YuvToJpgFrameBufferManager mBufferManager;
    public byte[] imageBuff;
    public String remoteIp = "";
    public String deviceId = "";
    boolean useJson = true;

    public SocketUtil() {
    }

    public Map<String, String> readJsonAsMap() throws Exception {
        String json = null;
        int len = 0;
        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) {
//                            System.out.println(FrameUtil.getFrames("Client")+" json="+json);
                            JsonParser parser = new JsonParser();
                            boolean isJSON = true;
                            JsonElement element = null;
                            try {
                                element = parser.parse(json);
                            } catch (JsonParseException e) {
                                System.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 (outputStream != null) {
//                outputStream.close();
//                outputStream = null;
//            }
//            if (inputStream != null) {
//                inputStream.close();
//                inputStream = null;
//            }
            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;
//        socket.setSoTimeout(10*1000);
        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 {
//        System.out.println("SocketUtil.openSocket " + FrameUtil.getFrames("Client"));
        close();
        SystemClock.sleep(Constants.reconnectInMilliSeconds);
        socket = new Socket();
//        socket.setSoTimeout(10*1000);
        socket.connect(new InetSocketAddress(ip, port), 10000);
        this.setSocket(socket);
    }

//    public void writeEmptyMessage() throws Exception {
//        outputStream.write('\0');
//        outputStream.flush();
//    }

    public void writeMessage(String key, String value) throws Exception {
        if (useJson) {
            JsonObject jsonObj = new JsonObject();
            jsonObj.addProperty(key, value);
            dataOutStream.write(jsonObj.toString().getBytes());
            dataOutStream.write('\0');
            dataOutStream.flush();
        } else {
//            JsonObject jsonObj = new JsonObject();
//            jsonObj.addProperty(key, value);
//            outputStream.write(jsonObj.toString().getBytes());
//            outputStream.write('\0');
//            outputStream.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());
        }
//        System.out.println("SocketUtil.writeMessage json="+jsonObj);
        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 {
//        if (dataInputStream == null) {
//            dataInputStream = new DataInputStream(inputStream);
//        }
        dataInputStream.readFully(imageBuff, 0, imageBuff.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);
    }

    public void readFrames(BitmapListener cameraDataListener) throws Exception {
        readFrameInfo();
        setBitmapListener(cameraDataListener);
        while (!Thread.currentThread().isInterrupted()) {
            this.readFullByteArray(imageBuff);
            mBufferManager.fillBuffer(imageBuff, imageBuff.length);
        }
    }

    public void readFrame(BitmapListener yuvToJpgFrameListener) throws Exception {
        readFrameInfo();
        setBitmapListener(yuvToJpgFrameListener);
        while (!Thread.currentThread().isInterrupted()) {
            this.readFullByteArray(imageBuff);
            mBufferManager.fillBuffer(imageBuff, imageBuff.length);
            break;
        }
    }

    public void writeFrameInfo() throws Exception {
        Map<String, String> map = new HashMap<>();
        map.put("type", "data");
        map.put("length", "460800");
        map.put("width", "640");
        map.put("height", "480");
        map.put("rotation", (Constants.isHuaWeiPad ? 270 : 90) + "");
        this.writeMessage(map);
    }

    public Map<String, String> getFrameInfo() {
        Map<String, String> frameInfo = new HashMap<>();
        frameInfo.put("type", "data");
        frameInfo.put("length", "460800");
        frameInfo.put("width", "640");
        frameInfo.put("height", "480");
        frameInfo.put("rotation", (Constants.isHuaWeiPad ? 270 : 90) + "");
        return frameInfo;
    }


    public void writeObject(Object object) throws Exception {
        if (useJson) {
            writeMessage((Map<String, String>) object);
        } else {
//            if (objectOutputStream == null) {
//                objectOutputStream = new ObjectOutputStream(outputStream);
//            }
//            objectOutputStream.writeObject(object);
//            objectOutputStream.flush();
        }
    }


    public void writeOneBitmap(Object object) throws Exception {
        if (useJson) {
            writeByteArray((byte[]) object);
        } else {
//            if (objectOutputStream == null) {
//                objectOutputStream = new ObjectOutputStream(outputStream);
//            }
//            objectOutputStream.writeObject(object);
//            objectOutputStream.flush();
        }
    }

    public void readObject(BitmapListener cameraDataListener) throws Exception {
        readFrameInfo();
        setBitmapListener(cameraDataListener);
        while (!Thread.currentThread().isInterrupted()) {
            this.readFullByteArray(imageBuff);
            mBufferManager.fillBuffer(imageBuff, imageBuff.length);
        }
    }

    public void readObject1(BitmapListener cameraDataListener) throws Exception {
        setBitmapListener(cameraDataListener);
        while (!Thread.currentThread().isInterrupted()) {
            this.readFullByteArray(imageBuff);
            mBufferManager.fillBuffer(imageBuff, imageBuff.length);
        }
    }

    public Object readObject() throws Exception {
        if (useJson) {
            return readJsonAsMap();
        } else {
            return readJsonAsMap();
//            if (objectInputStream == null) {
//                objectInputStream = new ObjectInputStream(inputStream);
//            }
//            return objectInputStream.readObject();
        }
    }

    public boolean remoteIpAllowed() {
        return OfficeDeviceManager.remoteIpAllowed(deviceId);
    }

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

    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", (Constants.isHuaWeiPad ? 270 : 90) + "");
            map.put("rotation", "270");
            success = true;
        } else {
            map.put(Constants.SUCCESS, Constants.FALSE);
            success = false;
        }
        if (useJson) {
            writeMessage(map);
        } else {
            writeObject(map);
        }
        return success;
    }

    public void readOneBitmap() throws Exception {
        if (useJson) {
            readFullByteArray(imageBuff);
            mBufferManager.fillBuffer(imageBuff, imageBuff.length);
        } else {
            byte[] frameData = (byte[]) this.readObject();
            mBufferManager.fillBuffer(frameData, frameData.length);
        }
    }

    public boolean writeMap(String key, String value) throws Exception {
        boolean success = false;
        Map<String, Object> map = new HashMap<>();
        if (remoteIpAllowed()) {
            if (key != null && value != null) {
                map.put(key, value);
            }
            map.put(Constants.SUCCESS, Constants.TRUE);
            success = true;
        } else {
            map.put(Constants.SUCCESS, Constants.FALSE);
            success = false;
        }
        writeObject(map);
        return success;
    }

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

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

    public Object readMapValueByKey(String key) throws Exception {
        return ((Map<String, Object>) readObject()).get(key);
    }

    public String readMapStringValueByKey(String key) throws Exception {
        if (useJson) {
            return readJsonAsMap().get(key);
        } else {
            return (String) ((Map<String, Object>) readObject()).get(key);
        }
    }

    public Object getBitmapHeader() {
        Map<String, String> map = new HashMap<>();
        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", (Constants.isHuaWeiPad ? 270 : 90) + "");
        return map;
    }

}