package ch.psi.mxsc;


import ch.psi.pshell.device.DeviceBase;
import ch.psi.utils.Arr;
import ch.psi.utils.Chrono;
import ch.psi.utils.State;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;


public class PuckDetection extends DeviceBase{   
    final String server;
    public volatile Chrono chrono;
    
    public PuckDetection(String name, String server){
        super(name);
        this.server = server.startsWith("tcp://") ? server : "tcp://" + server;
    }        
    
    Thread thread;
    Thread watchDog;
    
    @Override
    protected void doInitialize() throws IOException, InterruptedException{
        doClose();
        super.doInitialize();        
        
        chrono = new Chrono();
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                subscriberTask();
            }
        });
        thread.setDaemon(true);
        thread.start();
        
        watchDog = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    while (!Thread.currentThread().isInterrupted()) {
                        if (chrono.isTimeout(3000)){
                            setState(State.Offline);
                            MainPanel.getInstance().clearPuckStates();
                        }                        
                        Thread.sleep(1000);
                    }
                } catch (Exception ex){
                    getLogger().log(Level.INFO, null, ex);
                }
            }
        });
        watchDog.setDaemon(true);
        watchDog.start();        
    }
    
    
    void subscriberTask(){
        try{
            setState(State.Ready);           
            org.zeromq.ZMQ.Context context = org.zeromq.ZMQ.context(1);
            org.zeromq.ZMQ.Socket subscriber = context.socket(org.zeromq.ZMQ.SUB);
            subscriber.connect(server);
            subscriber.subscribe("Status".getBytes());
            try{
                while (!Thread.currentThread().isInterrupted()) {
                    String type = subscriber.recvStr();
                    System.out.println(type);
                    String contents = subscriber.recvStr();
                    System.out.println(contents);
                    processMessage(contents);
                    if (MainPanel.getInstance()!=null){
                        MainPanel.getInstance().repaint();
                    }
                    setState(State.Ready);
                    chrono = new Chrono();
                }
            } finally{
                MainPanel.getInstance().clearPuckStates();                
                subscriber.close();
                context.term();                                        
            }
        } catch (Exception ex){    
            getLogger().log(Level.INFO, null, ex);
        }
        setState(State.Offline);
    }
    
    void processMessage(String msg){        
        ArrayList<Integer> present = new ArrayList<>();
        for (String line:msg.split("\t")){
            try{
                line = line.trim();
                String[] tokens = line.split("  ");
                int id = Integer.valueOf(tokens[0].substring(1));
                present.add(id);
                PuckState puck = MainPanel.getInstance().getPuckState(id);
                if (tokens.length<3){
                    puck.clear();
                } else {
                    puck.set(tokens[1].trim().equals("1"),tokens[2].trim().equals("1"));
                }
            } catch (Exception ex){
                getLogger().log(Level.INFO, null, ex);
            }
        }
        for (int i=1; i<= MainPanel.NUMBER_OF_PUCKS; i++){
            if (!Arr.containsEqual(present.toArray(), i)){
                try{
                    MainPanel.getInstance().getPuckState(i).clear();
                } catch (Exception ex){
                    getLogger().log(Level.INFO, null, ex);
                }                    
            }
        }
    }
    
    @Override
    protected void doClose(){
        if (watchDog!=null){
            watchDog.interrupt();
            watchDog = null;
        }
        if (thread!=null){
            thread.interrupt();
            thread = null;
        }
    }
}