package ru.exponenta.mubotcontroller;

import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import com.felhr.usbserial.UsbSerialDevice;
import com.felhr.usbserial.UsbSerialInterface;

import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.Map;

public class FullscreenActivity extends AppCompatActivity{

    //devices PID, VID
    private final int[][] devicesFilter = {{1659, 8963}};
    private final String TAG = "MuBot";
    private static final String ACTION_USB_PERMISSION = "ru.exponenta.mubotcontroller.USB_PERMISSION";
    //
    private int InBufferSize = 192;
    private ByteBuffer inBuffer;

    private int BoundRate = 9600;

    private Button connect_Button;
    private Button disconnect_Button;

    private PendingIntent mPermissionIntent;
    private TextView input_Text;
    private UsbManager usbManager;
    private UsbDevice device;
    private UsbDeviceConnection connection = null;
    private UsbSerialDevice serialPort;
    private HashMap<String, UsbDevice> usbDevices;

    private UsbSerialInterface.UsbReadCallback mCallback;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fullscreen);

        connect_Button = (Button) findViewById(R.id.ConnectButton);
        disconnect_Button = (Button) findViewById(R.id.DisconnectButton);
        input_Text = (TextView) findViewById(R.id.InputText);

        inBuffer = ByteBuffer.allocate(InBufferSize);

        usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        mCallback = new UsbSerialInterface.UsbReadCallback()
        {
            @Override
            public void onReceivedData(byte[] arg0)
            {
                inBuffer.put(arg0);
                input_Text.append(new String(arg0));
            }
        };


        BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();

                if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
                    synchronized (this) {
                        UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                        if (device != null) {
                            onDisconnectClick(null);
                            Log.i(TAG, "Broadcast. Disconnected " + device.getDeviceName());
                        }
                    }
                } else if(UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action)) {

                    synchronized (this) {
                        UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

                        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                            if (device != null) {

                                onDeviceConnected(device);
                                Log.i(TAG, "Broadcast. Connected " + device.getDeviceName());
                            }
                        }
                        else {
                            Log.d(TAG, "permission denied for device " + device);
                        }

                    }
                } else if(ACTION_USB_PERMISSION.equals(action)){
                    synchronized (this){
                        UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

                        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                            if(device != null){
                                onDeviceConnected(device);
                            }
                        }
                        else {
                            Log.d(TAG, "permission denied for device " + device);
                        }

                    }
                }
            }
        };

        IntentFilter filter = new IntentFilter();
        filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
        filter.addAction(ACTION_USB_PERMISSION);
        registerReceiver(receiver, filter);

        mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(
                ACTION_USB_PERMISSION), 0);
        //IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        registerReceiver(receiver, filter);
    }

    @Override
    protected void onPostCreate(Bundle savedInstanceState) {
        super.onPostCreate(savedInstanceState);
    }

    public  void onDisconnectClick(View v) {

        if(serialPort != null) {
            serialPort.close();

            if (connection != null) {
                connection.close();
                connection = null;
                device = null;
            }

            connect_Button.setEnabled(true);
            disconnect_Button.setEnabled(false);
            Toast.makeText(this, "Disconnected!", Toast.LENGTH_SHORT).show();
        }
    }

    private boolean isContains(int vid, int pid){
        for (int[] s: devicesFilter) {
            if(s[0] ==  vid && s[1] == pid)
                return true;
        }
        return false;
    }

    public void onConnectClick(View v){
        usbDevices = usbManager.getDeviceList();
        if(!usbDevices.isEmpty())
        {
            for(Map.Entry<String, UsbDevice> entry : usbDevices.entrySet())
            {
                usbManager.requestPermission(device, mPermissionIntent);
                //device = entry.getValue();
                //onDeviceConnected(device);
            }
        }
    }

    private void onDeviceConnected(UsbDevice device){

        int deviceVID = device.getVendorId();
        int devicePID = device.getProductId();

        if(isContains(deviceVID, devicePID) && openSerialPort(device)) {

            Toast.makeText(this,"Connected" + device.getDeviceName(), Toast.LENGTH_SHORT).show();

            disconnect_Button.setEnabled(true);
            connect_Button.setEnabled(false);

            Log.i(TAG, "Connected " + device.getDeviceName());

        }else{
            connection = null;
            device = null;
        }
    }

    private boolean openSerialPort(UsbDevice device) {

        connection = usbManager.openDevice(device);
        serialPort = UsbSerialDevice.createUsbSerialDevice(device, connection);

        if(serialPort != null)
        {
            if(serialPort.open())
            {
                serialPort.setBaudRate(BoundRate);
                serialPort.setDataBits(UsbSerialInterface.DATA_BITS_8);
                serialPort.setStopBits(UsbSerialInterface.STOP_BITS_1);
                serialPort.setParity(UsbSerialInterface.PARITY_NONE);
                serialPort.setFlowControl(UsbSerialInterface.FLOW_CONTROL_OFF);
                serialPort.read(mCallback);

                return true;
            }else {
                Log.i(TAG,"Serial port open error!");
                return false;
            }
        }else{

            Log.i(TAG,"Serial port open error!");
            return false;
        }
    }

    @Override
    protected void onResume() {
        super.onResume();

    }
}