package com.example.demouhfapp;

import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.util.Log;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import com.zebra.rfid.api3.*;


import java.util.ArrayList;

public class MainActivity extends AppCompatActivity implements Readers.RFIDReaderEventHandler {
    static RFIDReader reader;
    TagData[] myTags;
    Readers readers;

    ArrayList<ReaderDevice> readersListArray;
    ReaderDevice readerDevice;
    boolean isReaderConnected = false;


    Button button;
    @SuppressLint("SetTextI18n")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        readers = new Readers(this, ENUM_TRANSPORT.SERVICE_SERIAL);

        try {
            readersListArray = readers.GetAvailableRFIDReaderList();
            readerDevice = readersListArray.get(0);
            reader = readerDevice.getRFIDReader();
        } catch (InvalidUsageException e) {
            e.printStackTrace();
        }

        connectReader();
        TagStorageSettings tagStorageSettings = null;
        try {
            tagStorageSettings = reader.Config.getTagStorageSettings();
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
        tagStorageSettings.setTagFields(TAG_FIELD.ALL_TAG_FIELDS);
        try {
            reader.Config.setTagStorageSettings(tagStorageSettings);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
        configureButton();
//        docs();

        Antennas.AntennaRfConfig antennaRfConfig = null;
        try {
            antennaRfConfig = reader.Config.Antennas.getAntennaRfConfig(1);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
//        antennaRfConfig.setrfModeTableIndex(0);
//        antennaRfConfig.setTari(0);
//        antennaRfConfig.setTransmitPowerIndex(270);


//        Antennas.SingulationControl singulationControl = null;
        try {
            reader.Config.Antennas.setAntennaRfConfig(1,antennaRfConfig);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
//        try {
//            singulationControl = reader.Config.Antennas.getSingulationControl(1);
//        } catch (InvalidUsageException | OperationFailureException e) {
//            e.printStackTrace();
//        }
//        singulationControl.setSession(SESSION.SESSION_S0);
//        singulationControl.setTagPopulation((short) 40);
//        singulationControl.Action.setSLFlag(SL_FLAG.SL_ALL);
//        singulationControl.Action.setInventoryState(INVENTORY_STATE.INVENTORY_STATE_A);
//        try {
//            reader.Config.Antennas.setSingulationControl(1, singulationControl);
//        } catch (InvalidUsageException | OperationFailureException e) {
//            e.printStackTrace();
//        }

        TAG_FIELD[] tagField = new TAG_FIELD[4];
        tagField[0] = TAG_FIELD.PC; tagField[1] =
                TAG_FIELD.PEAK_RSSI; tagField[2] =
                TAG_FIELD.TAG_SEEN_COUNT; tagField[3] =
                TAG_FIELD.CRC;
                try {
                    tagStorageSettings.setTagFields(tagField);
                } catch( Exception e) {
                    Toast.makeText(this, "Something unexpected happened", Toast.LENGTH_SHORT).show();
                    Log.d("MainActivity", "Something unexpected happened");
                }

        try {
            reader.Config.setTagStorageSettings(tagStorageSettings);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
        reader.Events.setInventoryStartEvent(true);
        reader.Events.setInventoryStopEvent(true);

//        Readers.RFIDReaderEventHandler eventHandler = new Readers.RFIDReaderEventHandler() {
//            @Override
//            public void RFIDReaderAppeared(ReaderDevice readerDevice) {
//
//            }
//
//            @Override
//            public void RFIDReaderDisappeared(ReaderDevice readerDevice) {
//
//            }
//        };


//        Readers.RFIDReaderEventHandler eventHandler = new Readers.RFIDReaderEventHandler() {
//            @Override
//            public void RFIDReaderAppeared(ReaderDevice readerDevice) {
//
//            }
//
//            @Override
//            public void RFIDReaderDisappeared(ReaderDevice readerDevice) {
//
//            }
//        };

        RfidEventsListener eventHandler = new RfidEventsListener() {
            @Override
            public void eventReadNotify(RfidReadEvents rfidReadEvents) {
            }

            @Override
            public void eventStatusNotify(RfidStatusEvents rfidStatusEvents) {
            }
        };
        try {
            reader.Events.addEventsListener(eventHandler);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }

        // Subscribe required status notification
        reader.Events.setInventoryStartEvent(true);
        reader.Events.setInventoryStopEvent(true);
        // enables tag read notification. if this is set to false, no tag read notification is send
        reader.Events.setTagReadEvent(true);
        reader.Events.setReaderDisconnectEvent(true);
        reader.Events.setBatteryEvent(true);

        //// CONTINUE FROM PAGE 33

//        try {
//            reader.Actions.Inventory.perform();
//            Log.d("MainActivityRFID", "Should start reading");
//            Toast.makeText(this, "should start reading", Toast.LENGTH_SHORT).show();
//        } catch (InvalidUsageException | OperationFailureException e) {
//            Toast.makeText(this, "Something went wrong while trying to read", Toast.LENGTH_SHORT).show();
//            e.printStackTrace();
//        }

        // tag event with tag data
        reader.Events.setTagReadEvent(true);
        // application will collect tag using getReadTags API
        reader.Events.setAttachTagDataWithReadEvent(false);

        TriggerInfo triggerInfo = new TriggerInfo();
        triggerInfo.StartTrigger.setTriggerType(START_TRIGGER_TYPE.START_TRIGGER_TYPE_IMMEDIATE);
        triggerInfo.StopTrigger.setTriggerType(STOP_TRIGGER_TYPE.STOP_TRIGGER_TYPE_IMMEDIATE);
        // set start and stop triggers
        try {
            reader.Config.setStartTrigger(triggerInfo.StartTrigger);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
        try {
            reader.Config.setStopTrigger(triggerInfo.StopTrigger);
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }

        Button button = findViewById(R.id.readButton);

            button.setOnClickListener(v -> {

                    // perform simple inventory

//                    reader.Actions.Inventory.perform();
                    eventReadNotify();

//                RFIDReaderEventHandler rfidReaderEventHandler = new RFIDReaderEventHandler();
//                rfidReaderEventHandler.eventReadNotify();

//                try {
//                    reader.Actions.Inventory.perform();
//                } catch (InvalidUsageException | OperationFailureException e) {
//                    Toast.makeText(this, "Didn't work", Toast.LENGTH_SHORT).show();
//                    e.printStackTrace();
//                }
//                Toast.makeText(this, Integer.toString(tagField[0].getValue()), Toast.LENGTH_SHORT).show();

            });

            TextView textView = findViewById(R.id.TagText);
        System.out.println("\nReader ID: " + reader.ReaderCapabilities.ReaderID.getID());
        System.out.println("\nModelName: " + reader.ReaderCapabilities.getModelName());
//        System.out.println("\nCommunication Standard: " + reader.ReaderCapabilities.getCommunicationStandard().toString());
        System.out.println("\nCountry Code: " + reader.ReaderCapabilities.getCountryCode());
        System.out.println("\nRSSI Filter: " + reader.ReaderCapabilities.isRSSIFilterSupported());
        System.out.println("\nTag Event Reporting: " + reader.ReaderCapabilities.isTagEventReportingSupported());
        System.out.println("\nTag Locating Reporting: " + reader.ReaderCapabilities.isTagLocationingSupported());
        System.out.println("\nNXP Command Support: " + reader.ReaderCapabilities.isNXPCommandSupported());
        System.out.println("\nBlockEraseSupport: " + reader.ReaderCapabilities.isBlockEraseSupported());
        System.out.println("\nBlockWriteSupport: " + reader.ReaderCapabilities.isBlockWriteSupported());
        System.out.println("\nBlockPermalockSupport:" + reader.ReaderCapabilities.isBlockPermalockSupported());
        System.out.println("\nRecommisionSupport: " + reader.ReaderCapabilities.isRecommisionSupported());
        System.out.println("\nWriteWMISupport:" + reader.ReaderCapabilities.isWriteUMISupported());
        System.out.println("\nRadioPowerControlSupport: " + reader.ReaderCapabilities.isRadioPowerControlSupported());System.out.println("\nHoppingEnabled: " + reader.ReaderCapabilities.isHoppingEnabled());
        System.out.println("\nStateAwareSingulationCapable: " + reader.ReaderCapabilities.isTagInventoryStateAwareSingulationSupported());
        System.out.println("\nUTCClockCapable: " + reader.ReaderCapabilities.isUTCClockSupported());System.out.println("\nNumOperationsInAccessSequence: " +        reader.ReaderCapabilities.getMaxNumOperationsInAccessSequence());
        System.out.println("\nNumPreFilters: " + reader.ReaderCapabilities.getMaxNumPreFilters());
        System.out.println("\nNumAntennaSupported: "  + reader.ReaderCapabilities.getNumAntennaSupported());


    }


//    private void getLinkedProfiles(ArrayList<String> linkedProfiles){
//        RFModeTable rfModeTable = rfidReader.ReaderCapabilities.RFModes.getRFModeTableInfo(0);
//        RFModeTableEntry rfModeTableEntry = null;
//        for (int i = 0; i < rfModeTable.length(); i++){
//            rfModeTableEntry = rfModeTable.getRFModeTableEntryInfo(i);
//            linkedProfiles.add(rfModeTableEntry.getBdrValue() + " " +
//                    rfModeTableEntry.getModulation() + " " + rfModeTableEntry.getPieValue() +
//                    " " + rfModeTableEntry.getMaxTariValue() + " " +
//                    rfModeTableEntry.getMaxTariValue() + " " + rfModeTableEntry.getStepTariValue());
//        }
//    }

    @Override
    protected void onStop() {
        super.onStop();
        readers.Dispose();
    }

//    private void ConfigureReader() {
//        if (reader.isConnected()) {
//            TriggerInfo triggerInfo = new TriggerInfo();
//            triggerInfo.StartTrigger.setTriggerType(START_TRIGGER_TYPE.START_TRIGGER_TYPE_IMMEDIATE);
//            triggerInfo.StopTrigger.setTriggerType(STOP_TRIGGER_TYPE.STOP_TRIGGER_TYPE_IMMEDIATE);
//            try {
//                // receive events from reader
//                if (eventHandler == null)
//                    eventHandler = new EventHandler();
//                reader.Events.addEventsListener(eventHandler);
//                // HH event
//                reader.Events.setHandheldEvent(true);
//                // tag event with tag data
//                reader.Events.setTagReadEvent(true);
//                // application will collect tag using getReadTags API
//                reader.Events.setAttachTagDataWithReadEvent(false);
//                // set trigger mode as rfid so scanner beam will not come
//                reader.Config.setTriggerMode(ENUM_TRIGGER_MODE.RFID_MODE, true);
//                // set start and stop triggers
//                reader.Config.setStartTrigger(triggerInfo.StartTrigger);
//                reader.Config.setStopTrigger(triggerInfo.StopTrigger);
//            } catch (InvalidUsageException e) {
//                e.printStackTrace();
//            } catch (OperationFailureException e) {
//                e.printStackTrace();
//            }
//        }
//    }

    @SuppressLint("SetTextI18n")
    private void configureButton() {
        button = findViewById(R.id.button);
        button.setOnClickListener(v -> {
//            try {
//                // stop the inventory
////                reader.Actions.Inventory.stop();
//                Toast.makeText(this, "Should stop reading.", Toast.LENGTH_SHORT).show();
//            } catch (InvalidUsageException | OperationFailureException e) {
//                Toast.makeText(this, "Something went wrong while trying to stop reading", Toast.LENGTH_SHORT).show();
//                e.printStackTrace();
//            }
//            if (isReaderConnected) {
//                button.setText("Read tags");
////                disconnectReader();
//
//
//            } else {
//                button.setText("stop reading");
////                connectReader();
//
//            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        readers.Dispose();
        try {
            reader.disconnect();
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
    }

    private void connectReader() {
        try {
            reader.connect();
            isReaderConnected = true;
            Log.d("MainActivity", "Reader connected successfully");
            Toast.makeText(this, "Reader connected successfully", Toast.LENGTH_SHORT).show();
        } catch (InvalidUsageException | OperationFailureException e) {
            isReaderConnected = false;
            e.printStackTrace();
        }
    }

    private void disconnectReader() {
        try {
            reader.disconnect();
            isReaderConnected = false;
            Log.d("MainActivity", "Reader disconnected successfully");
            Toast.makeText(this, "Reader disconnected successfully", Toast.LENGTH_SHORT).show();
        } catch (InvalidUsageException | OperationFailureException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void RFIDReaderAppeared(ReaderDevice readerDevice) {
        // handle reader addition
    }

    @Override
    public void RFIDReaderDisappeared(ReaderDevice readerDevice) {
        // handle reader removal
    }

    public void eventReadNotify() {
        myTags = MainActivity.reader.Actions.getReadTags(100);
            if (myTags != null) {
                for (TagData myTag : myTags) {
                    Log.d("MainActivity", "Tag ID " + myTag.getTagID());
                }
            }
    }
}

class RFIDReaderEventHandler implements RfidEventsListener {

    // Read Event Notification
//    public void eventReadNotify(RfidReadEvents e){
//        // Recommended to use new method getReadTagsEx for better performance in case of large
//        // tag population
//        TagData[] myTags = MainActivity.reader.Actions.getReadTags(100);
//        if (myTags != null) {
//            for (TagData myTag : myTags) {
//                System.out.println("Tag ID " + myTag.getTagID());
//                if (myTag.getOpCode() == ACCESS_OPERATION_CODE.ACCESS_OPERATION_READ
//                        && myTag.getOpStatus() == ACCESS_OPERATION_STATUS.ACCESS_SUCCESS) {
//                    if (myTag.getMemoryBankData().length() > 0) {
//                        System.out.println(" Mem Bank Data " +
//                                myTag.getMemoryBankData());
//                    }
//                }
//            }
//        }
//    }

    public void eventReadNotify(RfidReadEvents e) {
        TagData[] myTags = MainActivity.reader.Actions.getReadTags(100);
        if (myTags != null) {
            for (TagData myTag : myTags) {
                Log.d("MainActivity", "Tag ID " + myTag.getTagID());
            }
        }
    }
    // Status Event Notification
    public void eventStatusNotify(RfidStatusEvents e) {
        if (e.StatusEventData.getStatusEventType() == STATUS_EVENT_TYPE.INVENTORY_START_EVENT) {
            // Access operation started

        } else if(e.StatusEventData.getStatusEventType() == STATUS_EVENT_TYPE.INVENTORY_STOP_EVENT) {
            // Access operation stopped - Can be used to signal waiting thread
        }
    }

}

class EventHandler implements RfidEventsListener {
    // Read Event Notification
    public void eventReadNotify(RfidReadEvents e) {
        TagData tag = e.getReadEventData().tagData;
        if (tag.getOpCode() == ACCESS_OPERATION_CODE.ACCESS_OPERATION_READ
                && tag.getOpStatus() == ACCESS_OPERATION_STATUS.ACCESS_SUCCESS) {
            Log.d("Main Activity", "eventReadNotify - tag id " + tag.getTagID() + " and mem bank " + tag.getMemoryBankData());
        }
    }

    @Override
    public void eventStatusNotify(RfidStatusEvents rfidStatusEvents) {

    }
}