package com.example.demo1.web;

import java.io.*;
import java.net.URI;
import java.util.Map;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.handshake.ServerHandshake;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FunasrWsClient extends WebSocketClient {

    private static final Logger logger = LoggerFactory.getLogger(FunasrWsClient.class);

    private boolean iseof = false;
    private static String wavPath;
    private static String mode = "offline";
    private static String strChunkSize = "5,10,5";
    private static int chunkInterval = 10;
    private static int sendChunkSize = 1920;
    private static String hotwords="";
    private static String fsthotwords="";
    private String wavName = "javatest";
    private MyCallBack callBack;

    public FunasrWsClient(URI serverUri,MyCallBack callBack) {
        super(serverUri);
        this.callBack = callBack;
    }

    public FunasrWsClient(URI serverUri,String wavPath,MyCallBack callBack) {
        super(serverUri);
        this.callBack = callBack;
        this.wavPath = wavPath;
    }

    public FunasrWsClient(URI serverUri,String strChunkSize,int chunkInterval,String mode,String hotwords,String wavPath,MyCallBack callBack) {
        super(serverUri);
        this.callBack = callBack;
        this.strChunkSize = strChunkSize;
        this.chunkInterval = chunkInterval;
        this.mode = mode;
        this.fsthotwords = hotwords;
        this.wavPath = wavPath;

        int RATE = 16000;
        String[] chunkList = strChunkSize.split(",");
        int int_chunk_size = 60 * Integer.valueOf(chunkList[1].trim()) / chunkInterval;
        int CHUNK = Integer.valueOf(RATE / 1000 * int_chunk_size);
        this.sendChunkSize = CHUNK * 2;
    }

    public class RecWavThread extends Thread {
        private FunasrWsClient funasrClient;

        public RecWavThread(FunasrWsClient funasrClient) {
            this.funasrClient = funasrClient;
        }

        public void run() {
            this.funasrClient.recWav();
        }
    }

    public FunasrWsClient(URI serverUri, Draft draft) {
        super(serverUri, draft);
    }

    public FunasrWsClient(URI serverURI) {

        super(serverURI);
    }

    public FunasrWsClient(URI serverUri, Map<String, String> httpHeaders) {
        super(serverUri, httpHeaders);
    }

    public void getSslContext(String keyfile, String certfile) {
        // TODO
        return;
    }


    public void sendJson(
        String mode, String strChunkSize, int chunkInterval, String wavName, boolean isSpeaking,String suffix) {
        try {

            JSONObject obj = new JSONObject();
            obj.put("mode", mode);
            JSONArray array = new JSONArray();
            String[] chunkList = strChunkSize.split(",");
            for (int i = 0; i < chunkList.length; i++) {
                array.add(Integer.valueOf(chunkList[i].trim()));
            }

            obj.put("chunk_size", array);
            obj.put("chunk_interval", new Integer(chunkInterval));
            obj.put("wav_name", wavName);

            if(FunasrWsClient.hotwords.trim().length()>0)
            {
                String regex = "\\d+";
                JSONObject jsonitems = new JSONObject();
                String[] items=FunasrWsClient.hotwords.trim().split(" ");
                Pattern pattern = Pattern.compile(regex);
                String tmpWords="";
                for(int i=0;i<items.length;i++)
                {

                    Matcher matcher = pattern.matcher(items[i]);

                    if (matcher.matches()) {

                        jsonitems.put(tmpWords.trim(), items[i].trim());
                        tmpWords="";
                        continue;
                    }
                    tmpWords=tmpWords+items[i]+" ";

                }



                obj.put("hotwords", jsonitems.toString());
            }

            if(suffix.equals("wav")){
                suffix="pcm";
            }
            obj.put("wav_format", suffix);
            if (isSpeaking) {
                obj.put("is_speaking", new Boolean(true));
            } else {
                obj.put("is_speaking", new Boolean(false));
            }
            logger.info("sendJson: " + obj);
            // return;

            send(obj.toString());

            return;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 
    public void sendEof() {
        try {
            JSONObject obj = new JSONObject();

            obj.put("is_speaking", new Boolean(false));

            logger.info("sendEof: " + obj);
            // return;

            send(obj.toString());
            iseof = true;
            return;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

   
    public void recWav() {
        String fileName=FunasrWsClient.wavPath;
        String suffix=fileName.split("\\.")[fileName.split("\\.").length-1];
        sendJson(mode, strChunkSize, chunkInterval, wavName, true,suffix);
        File file = new File(FunasrWsClient.wavPath);

        int chunkSize = sendChunkSize;
        byte[] bytes = new byte[chunkSize];

        int readSize = 0;
        try (FileInputStream fis = new FileInputStream(file)) {
            if (FunasrWsClient.wavPath.endsWith(".wav")) {
                fis.read(bytes, 0, 44); 
            }
            readSize = fis.read(bytes, 0, chunkSize);
            while (readSize > 0) {
                if (readSize == chunkSize) {
                    send(bytes); 

                } else {
                    byte[] tmpBytes = new byte[readSize];
                    for (int i = 0; i < readSize; i++) {
                        tmpBytes[i] = bytes[i];
                    }
                    send(tmpBytes);
                }
                
                if (!mode.equals("offline")) {
                    Thread.sleep(Integer.valueOf(chunkSize / 32));
                }

                readSize = fis.read(bytes, 0, chunkSize);
            }

            if (!mode.equals("offline")) {
                Thread.sleep(2000);
                sendEof();
                Thread.sleep(3000);
                close();
            } else {
                sendEof();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {

        RecWavThread thread = new RecWavThread(this);
        thread.start();
    }

    @Override
    public void onMessage(String message) {
        JSONObject jsonObject = new JSONObject();
        JSONParser jsonParser = new JSONParser();
        logger.info("received: " + message);
        try {
            jsonObject = (JSONObject) jsonParser.parse(message);
            logger.info("text: " + jsonObject.get("text"));
            callBack.callBack(jsonObject.get("text"));
            if(jsonObject.containsKey("timestamp"))
            {
                logger.info("timestamp: " + jsonObject.get("timestamp"));
            }
        } catch (org.json.simple.parser.ParseException e) {
            e.printStackTrace();
        }
        if (iseof && mode.equals("offline") && !jsonObject.containsKey("is_final")) {
            close();
        }

        if (iseof && mode.equals("offline") && jsonObject.containsKey("is_final") && jsonObject.get("is_final").equals("false")) {
            close();
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {

        logger.info(
                "Connection closed by "
                        + (remote ? "remote peer" : "us")
                        + " Code: "
                        + code
                        + " Reason: "
                        + reason);
    }

    @Override
    public void onError(Exception ex) {
        logger.info("ex: " + ex);
        ex.printStackTrace();
    }

}