package com.sunvote.xpadcomm;

import android.os.Handler;
import android.os.HandlerThread;

import com.sunvote.util.LogUtil;

import java.io.UnsupportedEncodingException;

/**
 * Created by Elvis on 2018/3/27 9:48
 * Email:Eluis@psunsky.com
 * 版权所有：长沙中天电子设计开发有限公司
 * Description: 人大通用版
 * 短消息上传模块
 */
public class RFMessageUploadModule {

    public static final byte PACKTYPE = 3 ;
    private static RFMessageUploadModule instance ;

    private IUploadListener uploadListener ;

    private String filename;
    private byte[] datas = "test message".getBytes();
    private int length = 1024;
    private HandlerThread handlerThread ;
    private Handler handler ;
    private byte[] keyid;
    private Runnable task;
    private int packTotal ;
    private boolean stop = false;

    private RFMessageUploadModule(){
        handlerThread = new HandlerThread(RFMessageUploadModule.class.getSimpleName());
        handlerThread.start();
        handler = new Handler(handlerThread.getLooper());
    }

    public static RFMessageUploadModule getInstance() {
        if(instance == null){
            instance = new RFMessageUploadModule();
        }
        return instance;
    }

    public void setMessageContent(byte[] messageContent) {
        this.datas = messageContent;
        uploadMsgData(datas);
        removeTask();
    }

    public void setMessageContent(String message) {
        try {
            this.datas = message.getBytes("GB2312");
            uploadMsgData(datas);
            removeTask();
            handler.removeCallbacks(failCall);
            handler.postDelayed(failCall,10000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean uploadMsgData(byte[] ds){
        System.out.println("uploadMsgData" + ds);
        if(ds != null){
            length = ds.length ;
            filename = null ;
            this.datas = new byte[length ];
            System.arraycopy(ds,0,this.datas,0,length);
//            this.datas[length] = 0x13 ;
//            this.datas[length + 1] = 0x0 ;
//            this.datas[length + 2] = 0x10 ;
//            this.datas[length + 3] = 0x0 ;
            task = new A0(filename,length);
            handler.removeCallbacks(task);
            handler.post(task);
            return true;
        }
        return false;
    }


    public void setKeyid(byte[] keyid) {
        this.keyid = keyid;
    }

    public void uploadData(byte packid, byte packH, byte[] packLs){
        System.out.println("uploadData");
        handler.removeCallbacks(task);
        task = new A2(keyid,packid,packH,datas,packLs);
        handler.post(task);
        if(uploadListener != null){
            double process = 0 ;
            if(packTotal > 0){
                int count = 0 ;
                int sen = (packLs[1] & 0xFF) * 256 + (packLs[0]  & 0XFF);
                for(int i = 0 ; i < 16 ; i++){
                    if((sen & (1 << i)) != 0){
                        count ++ ;
                    }
                }
                process = (double)(packH * 16 + count) / packTotal ;
            }
            uploadListener.onUploadProcess(process);
        }
    }

    public void packetConfirmation(byte packid){
        System.out.println("packetConfirmation");
        handler.removeCallbacks(task);
        byte[] names = null;
        if(filename != null){
            try {
                names = filename.getBytes("GB2312");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        task = new A1(keyid,(byte)((length  ) / 65535), (byte)(((length )  % 65535) / 256),(byte)(((length ) % 256 / 16 + (length % 16 == 0 ? 0 : 1))),names);
        handler.post(task);
    }

    public void packetReceptionConfirmed(byte packid,byte packH){
        System.out.println("packetReceptionConfirmed");
        handler.removeCallbacks(task);
        task = new A3(keyid,packid,packH);
        handler.post(task);
    }

    public boolean uploadMessage(byte[] datas){
        System.out.println("uploadMsgData" + datas);
        if(datas != null){
            length = datas.length ;
            filename = null ;
            this.datas = new byte[length ];
            System.arraycopy(datas,0,this.datas,0,length);
//            datas[length] = 0x13 ;
//            datas[length + 1] = 0x0 ;
//            datas[length + 2] = 0x10 ;
//            datas[length + 3] = 0x0 ;
            task = new A0(filename,length);
            handler.removeCallbacks(task);
            handler.post(task);
            return true;
        }
        return false;
    }


    public void setUploadListener(IUploadListener uploadListener) {
        this.uploadListener = uploadListener;
    }

    class A0 implements Runnable{
        private int length ;
        private String filename;
        private int times ;
        public A0(String filename,int length){
            this.length = length ;
            this.filename = filename;
            packTotal = length / 16  + 1;
            times = 0 ;
        }

        @Override
        public void run() {
            XPadApi.getInstance().applyFileUpload(this.length,this.filename,PACKTYPE,RFFileUploadModule.index);
        }
    }

    class A1 implements Runnable{

        private byte[] keyid;
        private byte packid ;
        private byte packH ;
        private byte packL ;
        private byte[] names ;
        private int times ;

        public A1(byte[] keyid, byte packid,byte packH,byte packL,byte[] names) {
            this.keyid = keyid;
            this.packid = packid;
            this.packH = packH ;
            this.packL = packL ;
            this.names = names ;
            times = 0 ;
        }

        @Override
        public void run() {
            XPadApi.getInstance().packetConfirmation(this.keyid,this.packid,this.packH,this.packL,this.names,PACKTYPE);
            times ++ ;
            if(task != null && times < 5){
                handler.postDelayed(task,1000);
            }
            if(uploadListener != null){
                uploadListener.onUploadStart();
            }

            handler.removeCallbacks(failCall);
            handler.postDelayed(failCall,10000);
        }
    }

    class A2 implements Runnable{
        private byte[] keyid;
        private byte packid;
        private byte packH;
        private byte[] datas ;
        private byte[] packLs;
        private int times ;

        public A2(byte[] keyid, byte packid, byte packH, byte[] datas, byte[] packLs) {
            this.keyid = keyid;
            this.packid = packid;
            this.packH = packH;
            this.datas = datas;
            this.packLs = packLs;
            times = 0 ;
        }

        @Override
        public void run() {

            int packLsi = packLs[1] * 256 + packLs[0];
            int offset = 0 ;
            int length = 16;
            System.out.println("packLsi:" + packLsi);
            for(byte packL = 0 ;packL < 16 ;packL ++) {
                if((packLsi & (1 << packL)) != 0){
                    offset = ((packid * 65535) + (packH) * 256 + 16 * (packL)) & 0xFFFF;
                    XPadApi.getInstance().uploadFileData(this.keyid, this.packid, this.packH, (byte)(packL), this.datas, offset, length,PACKTYPE);
                    try{
                        Thread.sleep(50);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            times ++ ;
            if(task != null && times < 5){
                handler.postDelayed(task,1000);
            }
            handler.removeCallbacks(failCall);
            handler.postDelayed(failCall,10000);
        }
    }

    class A3 implements Runnable{
        private byte[] keyid;
        private byte packid ;
        private byte packH;

        public A3(byte[] keyid, byte packid, byte packH) {
            this.keyid = keyid;
            this.packid = packid;
            this.packH = packH;
        }

        @Override
        public void run() {
            XPadApi.getInstance().packetReceptionConfirmed(this.keyid,this.packid,this.packH,PACKTYPE);
            if(uploadListener != null){
                uploadListener.onUploadStop();
            }
            handler.removeCallbacks(failCall);
        }
    }

    public void onUploadMessage(byte data, byte[] keyid, byte packid, byte packH, byte[] packLs) {
        LogUtil.i("RFMessageUploadModule","onUploadMessage:" + data);
        if (data == 1) {
           setKeyid(keyid);
           packetConfirmation(packid);
        }
        if (data == 2) {
            uploadData(packid, packH, packLs);
        }
        if (data == 3) {
           packetReceptionConfirmed(packid, packH);
        }
    }

    private void removeTask(){
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                handler.removeCallbacks(task);
            }
        },5000);
    }

    private Runnable failCall = new Runnable() {
        @Override
        public void run() {
            if(uploadListener != null){
                uploadListener.onFail();
            }
        }
    };
}