package art.client.maps;

import art.client.models.Shared;
import art.library.interop.serialization.Serialization;
import art.library.model.devices.Device;
import art.library.model.devices.DeviceGraphicsRuntime;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.barrier.Barrier;
import art.library.model.devices.barrier.BarrierAlarms;
import art.library.model.devices.barrier.BarrierRealtime;
import art.library.model.devices.barrier.BarrierStatus;
import art.library.model.devices.barrier.realtime.BarrierRealtimeITC;
import art.library.model.devices.cctv.camera.Camera;
import art.library.model.devices.cctv.camera.CameraStatus;
import art.library.model.devices.signalsboard.SignalsBoard;
import art.library.model.devices.signalsboard.status.SignalStatus;
import art.library.model.devices.vms.asf.Asf;
import art.library.model.devices.vms.asf.AsfStatus;
import art.library.model.devices.vms.general.VmsGeneral;
import art.library.model.devices.vms.general.status.VmsGeneralStatusMessage;
import static art.library.utils.ArticScalableVectorGraphics.getBoundingBox;
import art.library.vmsboard.BoardDocument;
import com.kitfox.svg.*;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.image.BufferedImage;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class TunnelAlmeria extends DeviceGraphicsRuntime
{
    private boolean even = false;
    private final  DecimalFormat decimalFormat = new DecimalFormat("0.00");
   
    public TunnelAlmeria (SVGDiagram diagram)
    {
        super(diagram);
    }
    
    public void status()
    {

        Calendar calendardate = java.util.Calendar.getInstance();
        calendardate.set(java.util.Calendar.MILLISECOND, 0);
        long seconds = calendardate.getTimeInMillis() / 1000;
        even = (seconds % 2) == 0;

        for (SVGElement element : getElementsContainingField("art.device"))
        {
            try
            {
               
                
                for (Class deviceClass : Shared.model.modelDevices.getDevicesListRead().stream().map(Device::getClass).collect(Collectors.toSet()))
                {
                    if (Shared.model.modelDevices.getDevice(getAttribute(element, "art.device")).getClassName().equals(deviceClass.getName()))
                    {
                        this.getClass()
                                .getMethod("status", deviceClass, SVGElement.class)
                                .invoke(this, Shared.model.modelDevices.getDevice(getAttribute(element, "art.device")), element);
                        break;
                    }
                }
            } catch (Exception e){}
        }
    }

    //<editor-fold defaultstate="collapsed" desc="SignalsBoard">
    public void status(SignalsBoard svgDevice, SVGElement element)
    {
        String[] signals = getAttribute(element, "art.device.signal").contains(";") 
                ? getAttribute(element, "art.device.signal").split(";") 
                : new String[] {getAttribute(element, "art.device.signal")} ;
        
        if (signals.length > 0)
        {
            SignalStatus signal = svgDevice.getDeviceStatus().getSignal(signals[0]);
         
            if (signal != null)
            {
                setText(element, decimalFormat.format(Float.valueOf(signal.value)) + " " + (signal.units != null ? Shared.getMessage(signal.units) : ""));
            } 
            else
            {
                boolean floodAlarm = Stream.of(signals).anyMatch(signalAlarm -> svgDevice.getAlarm(signalAlarm) > 0);

                if (signals.length > 1)
                {
                    setAttribute(element, "display", floodAlarm ? "inline" : "none", 999);
                }
                else
                {
                    String backgroundColor = "#FF00FF";
                    
                    switch (svgDevice.getDeviceStatus().status)
                    {
                        case DeviceStatus.STATUS_ALARM: backgroundColor = "#00FF00";
                        case DeviceStatus.STATUS_ONLINE: backgroundColor = "#00FF00";
                            break;
                    }
                    
                    if(floodAlarm)
                    {
                        backgroundColor = "#FF0000";
                    }
                    
                    setAttribute(element, "fill", backgroundColor, 999);
                }
            }
        }
    }
//</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="ASF">
    public void status(Asf svgDevice, SVGElement element) throws Exception
    {

        if (element.getStyleAbsolute("display").getStringValue().equals("none"))
            return;
        
        AsfStatus status = svgDevice.getDeviceStatus();

        SVGElement alarm = getChildContainingField(element,"art.id","Alarm");
        SVGElement background = getChildContainingField(element,"art.id","Background");
        SVGElement arrow = getChildContainingField(element,"art.id","Arrow");
        SVGElement cross = getChildContainingField(element,"art.id","Cross");
        SVGElement right = getChildContainingField(element, "art.id", "Right");
        SVGElement left = getChildContainingField(element, "art.id", "Left");

        setAttribute(alarm, "display", "none", 999);
        setAttribute(arrow, "display", "none", 999);
        setAttribute(cross, "display", "none", 999);
        setAttribute(right, "display", "none", 999);
        setAttribute(left, "display", "none", 999);

        boolean knownStatus = status.state != DeviceStatus.STATUS_OFFLINE && status.state != DeviceStatus.STATUS_UNKNOWN;

        if (knownStatus)
        {
            setAttribute(arrow, "display", status.state == AsfStatus.STATE_ARROW  ? "inline" : "none", 999);
            setAttribute(cross, "display", status.state == AsfStatus.STATE_CROSS  ? "inline" : "none", 999);
            setAttribute(right, "display", status.state == AsfStatus.STATE_RIGHT  ? "inline" : "none", 999);
            setAttribute(left, "display", status.state == AsfStatus.STATE_LEFT  ? "inline" : "none", 999);
        }

        String colorBackground = "#000000";

        switch (status.status)
        {
            case DeviceStatus.STATUS_ALARM:
                setAttribute(alarm, "display", "inline",999);
                  break;
            case DeviceStatus.STATUS_OFFLINE:
            case DeviceStatus.STATUS_UNKNOWN:
                colorBackground = "#FF00FF";
                break;
        }

        setAttribute(background, "fill", colorBackground,999);
    }
//</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="VmsGeneral">
    public void status(VmsGeneral svgDevice, SVGElement element) throws Exception
    {
        if (element.getStyleAbsolute("display").getStringValue().equals("none"))
        {
            return;
        }
        
        SVGElement background = getChildContainingField(element,"art.id","Background");
        SVGElement alarm = getChildContainingField(element, "art.id","Alarm");
        
        String backGroundColor = "#000000";
        String alarmColor = "#00FF00";
        
        switch (svgDevice.getDeviceStatus().status)
        {
            case DeviceStatus.STATUS_ALARM:
                alarmColor = "#FF0000";
                break;
            case DeviceStatus.STATUS_OFFLINE:
            case DeviceStatus.STATUS_UNKNOWN:
                backGroundColor = "#FF00FF";
                alarmColor = "#800080";
                break;
        }

        setAttribute(background, "fill", backGroundColor,999);
        setAttribute(alarm, "stroke", alarmColor,999);
    }
//</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Barrier">
    public void status(Barrier svgDevice, SVGElement element) throws Exception //BARRIER
    {
        if (element.getStyleAbsolute("display").getStringValue().equals("none"))
        {
            return;
        }

        if (getChildContainingField(element, "art.id", "Semaphore.Arrow") != null)
        {
            barrierSignalStatus(element, svgDevice);
        } 
        else
        {
            BarrierRealtimeITC realtime = ((BarrierRealtime) svgDevice.getDeviceRealtime()).itc;
            {
                barrierStatus(element, realtime);
                semaphoreStatus(element, realtime);
            }

            barrierDeviceStatus(element, svgDevice.getDeviceStatus());
            barrierAlarms(element, svgDevice.getDeviceAlarms(), realtime);
        }
    }

    private void barrierStatus(SVGElement element, BarrierRealtimeITC realtimeItc)
    {
        SVGElement[] barrierElements = new SVGElement[]
        {
            getChildContainingField(element,"art.id","Barrier.Closed"),
            getChildContainingField(element,"art.id","Barrier.Closing"),
            getChildContainingField(element,"art.id","Barrier.Opening"),
            getChildContainingField(element,"art.id","Barrier.Locked")
        };

        Stream.of(barrierElements).forEach(svgElement -> setAttribute(svgElement, "display", "none", 999));
        setAttribute(barrierElements[3], "fill", "#FF0000", 999);
        SVGElement elementToShow = null;

        switch (realtimeItc.position)
        {
            case BarrierRealtimeITC.POSITION_DOWN: elementToShow = barrierElements[0]; break;
            case BarrierRealtimeITC.POSITION_CLOSING: elementToShow = barrierElements[1]; break;
            case BarrierRealtimeITC.POSITION_OPENING: elementToShow = barrierElements[2]; break;
        }
        
        
        
        switch (realtimeItc.lock)
        {
            case BarrierRealtimeITC.LOCK_LOCK:
                setAttribute(barrierElements[3], "display", "inline", 999);
                break;
            case BarrierRealtimeITC.LOCK_UNLOCK:
                setAttribute(barrierElements[3], "display", "none", 999);
                break;
            case BarrierRealtimeITC.LOCK_UNKNOWN:
                setAttribute(barrierElements[3], "display", "inline", 999);
                setAttribute(barrierElements[3], "fill", "#FF00FF", 999);
                break;
        }

        if(elementToShow != null)
            setAttribute(elementToShow, "display", "inline", 999);
        
    }
    
    private void barrierSignalStatus(SVGElement element, Barrier svgDevice)
    {
        SVGElement background = getChildContainingField(element, "art.id", "Barrier.Background");
        SVGElement semaphoreArrow = getChildContainingField(element, "art.id", "Semaphore.Arrow");
     
        setAttribute(semaphoreArrow, "display", "none", 999);

        switch (svgDevice.getDeviceStatus().status)
        {
            case DeviceStatus.STATUS_UNKNOWN:
            case DeviceStatus.STATUS_OFFLINE:
                setAttribute(background, "fill", "#FF00FF",999);
                break;
            default:
                setAttribute(background, "fill", "#808080",999);
                break;
        }

        if (device.getDeviceRealtime() != null)
        {
            BarrierRealtime realtime = ((Barrier) device).getDeviceRealtime();

            if (realtime.itc != null)
            {
                BarrierRealtimeITC realtimeITC = realtime.itc;

                setAttribute(semaphoreArrow, "display",
                         realtimeITC.trafficLight == BarrierRealtimeITC.TRAFFIC_LIGHT_RED
                                ? "inline"
                                : "none",
                         999);
                
                if(realtimeITC.trafficLight == BarrierRealtimeITC.TRAFFIC_LIGHT_UNKNOWN)
                      setAttribute(background, "fill", "#FF00FF",999);
            }
        }

    }

    private void roadSensor(SVGElement element, BarrierRealtimeITC realtimeItc)
    {
        SVGElement loop1 = getChildContainingField(element,"art.id","Loop1");
        SVGElement loop2 = getChildContainingField(element,"art.id","Loop2");
        
        setAttribute(loop1, "fill", "#E0E0E0");
        setAttribute(loop2,"fill", "#E0E0E0");
        
        if (realtimeItc.loopInput == BarrierRealtimeITC.LOOP_ACTIVE)
            setAttribute(loop1, "fill", "#FFFF00");
        if (realtimeItc.loopOutput == BarrierRealtimeITC.LOOP_ACTIVE)
            setAttribute(loop2, "fill", "#FFFF00");

    }

    private void semaphoreStatus(SVGElement element, BarrierRealtimeITC realtimeItc)
    {

        SVGElement semaphoreRed = getChildContainingField(element,"art.id","Semaphore.Red");
        SVGElement semaphoreYellow = getChildContainingField(element,"art.id","Semaphore.Yellow");
        SVGElement semaphoreGreen = getChildContainingField(element,"art.id","Semaphore.Green");

        setAttribute(semaphoreGreen, "fill", "#000000",999);
        setAttribute(semaphoreYellow, "fill", "#000000",999);
        setAttribute(semaphoreRed, "fill", "#000000", 999);

        switch (realtimeItc.trafficLight)
        {
            case BarrierRealtimeITC.TRAFFIC_LIGHT_GREEN:
                setAttribute(semaphoreGreen, "fill", "#00FF00", 999);
                break;
            case BarrierRealtimeITC.TRAFFIC_LIGHT_YELLOW:
                setAttribute(semaphoreYellow, "fill", "#FFFF00", 999);
                break;
            case BarrierRealtimeITC.TRAFFIC_LIGHT_RED:
                setAttribute(semaphoreRed, "fill", "#FF0000", 999);
                break;
            case BarrierRealtimeITC.TRAFFIC_LIGHT_UNKNOWN:
                setAttribute(semaphoreGreen, "fill", "#800080", 999);
                setAttribute(semaphoreYellow, "fill", "#800080", 999);
                setAttribute(semaphoreRed, "fill", "#800080", 999);
                break;
        }
    }

    private void barrierAlarms(SVGElement element, BarrierAlarms alarms,  BarrierRealtimeITC realtimeItc)
    {
        String[] semaphoreAlarms = new String[]
        {
            "alarm_blown_green",
            "alarm_blown_yellow",
            "alarm_blown_red",
            "alarm_damaged_green",
            "alarm_damaged_green",
            "alarm_damaged_red"
        };

        String[] barrierAlarms = new String[]
        {
            "alarm_opening",
            "alarm_closing",
            "alarm_broken",
            "alarm_manual",
            "alarm_closed"
        };

        boolean semaphoreActiveAlarm = Stream.of(semaphoreAlarms).anyMatch(alarm -> alarms.getAlarm(alarm) > 0);
        boolean barrierActiveAlarm = Stream.of(barrierAlarms).anyMatch(alarm -> alarms.getAlarm(alarm) > 0);
        boolean semaphoreStatusUnknown = realtimeItc.trafficLight == BarrierRealtimeITC.TRAFFIC_LIGHT_UNKNOWN;
        boolean barrierStatusUnknown = realtimeItc.position == BarrierRealtimeITC.POSITION_UNKNOWN;

        SVGElement semaphoreAlarm = getChildContainingField(element, "art.id", "Semaphore.Alarm");
        SVGElement barrierAlarm = getChildContainingField(element, "art.id", "Barrier.Alarm");
        SVGElement barrierBackground = getChildContainingField(element, "art.id", "Barrier.Background");
        SVGElement semaphoreBackground = getChildContainingField(element,"art.id","Semaphore.Background");
        
        setAttribute(semaphoreAlarm, "display", "none", 999);
        setAttribute(barrierAlarm, "display", "none", 999);
        setAttribute(barrierBackground, "fill", "#FF00FF", 999);
        setAttribute(semaphoreBackground, "fill", "#FF00FF", 999);
        
        if(!barrierStatusUnknown)
           setAttribute(barrierBackground, "fill", barrierActiveAlarm ? "#FF0000" : "#00FF00", 999);
        if(!semaphoreStatusUnknown)
           setAttribute(semaphoreBackground, "fill","#808080", 999);

        if (barrierActiveAlarm && !barrierStatusUnknown)
            setAttribute(barrierAlarm, "display", "inline",999);
        if(semaphoreActiveAlarm && !semaphoreStatusUnknown)
            setAttribute(semaphoreAlarm, "display", "inline",999);
    }
    
    private void barrierDeviceStatus(SVGElement element, BarrierStatus deviceStatus)
    {
        SVGElement barrierBackground = getChildContainingField(element, "art.id", "Barrier.Background");
        SVGElement semaphoreBackground = getChildContainingField(element, "art.id", "Semaphore.Background");
        SVGElement semaphoreAlarm = getChildContainingField(element, "art.id", "Semaphore.Alarm");
        SVGElement barrierAlarm = getChildContainingField(element, "art.id", "Barrier.Alarm");
        SVGElement barrierLock = getChildContainingField(element, "art.id", "Barrier.Locked");
        SVGElement barrierClosed = getChildContainingField(element, "art.id", "Barrier.Closed");
        SVGElement barrierClosing = getChildContainingField(element, "art.id", "Barrier.Closing");
        SVGElement barrierOpening = getChildContainingField(element, "art.id", "Barrier.Opening");
        SVGElement semaphoreRed = getChildContainingField(element, "art.id", "Semaphore.Red");
        SVGElement semaphoreYellow = getChildContainingField(element, "art.id", "Semaphore.Yellow");
        SVGElement semaphoreGreen = getChildContainingField(element, "art.id", "Semaphore.Green");

        String statusOfflineColor = "#FF00FF";
        String statusOfflineColorDarker = "#800080";

        switch (deviceStatus.status)
        {
            case DeviceStatus.STATUS_OFFLINE:
            case DeviceStatus.STATUS_UNKNOWN:
                setAttribute(barrierBackground, "fill", statusOfflineColor, 999);
                setAttribute(semaphoreBackground, "fill", statusOfflineColor, 999);
                setAttribute(semaphoreRed, "fill", statusOfflineColorDarker, 999);
                setAttribute(semaphoreYellow, "fill", statusOfflineColorDarker, 999);
                setAttribute(semaphoreGreen, "fill", statusOfflineColorDarker, 999);
                setAttribute(semaphoreAlarm, "display", "none", 999);
                setAttribute(barrierAlarm, "display", "none", 999);
                setAttribute(barrierLock, "display", "none", 999);
                setAttribute(barrierClosed, "display", "none", 999);
                setAttribute(barrierClosing, "display", "none", 999);
                setAttribute(barrierOpening, "display", "none", 999);
                break;
        }

    }
//</editor-fold>
    
    //<editor-fold defaultstate="collapsed" desc="Camera">
    public void status(Camera svgDevice, SVGElement element) throws Exception
    {
        if (element.getStyleAbsolute("display").getStringValue().equals("none"))
            return;

        CameraStatus status = svgDevice.getDeviceStatus();
        String colorBackground = "#808080";

        switch (status.status)
        {
            case DeviceStatus.STATUS_ALARM:
                colorBackground = "#FF0000";
                break;
            case DeviceStatus.STATUS_OFFLINE:
            case DeviceStatus.STATUS_UNKNOWN:
                colorBackground = "#FF00FF";
                break;
        }

        setAttribute(element, "fill", colorBackground, 999);
    }
//</editor-fold>
    
    //<editor-fold defaultstate="collapsed" desc="VMS MESSAGE PAINTING">
    private final HashMap<String,VmsMessageStorage> mapMessages = new HashMap<>();
    
    public void paint(Graphics2D g2)
    {
        for (SVGElement element : getElementsContainingField("art.device"))
        {
            Device device = Shared.model.modelDevices.getDevice(getAttribute(element, "art.device"));
            
            if (device instanceof VmsGeneral)
            {
                if(element.getStyleAbsolute("display").getStringValue().equals("none"))
                    continue;
                
                VmsGeneral vms = (VmsGeneral) device;
                
                VmsMessageStorage storemessage = new VmsMessageStorage();
                
                if(!mapMessages.containsKey(vms.getIdentifier()))
                    mapMessages.put(vms.getIdentifier(),storemessage);
                
                VmsMessageStorage messageStore = mapMessages.get(vms.getIdentifier());
                
                SVGElement background = getChildContainingField(element, "art.id", "Background");
                Shape shape = getBoundingBox(background);
                
                double w = shape.getBounds2D().getWidth() * g2.getTransform().getScaleX();
                double h = shape.getBounds2D().getHeight() * g2.getTransform().getScaleY();
                
                
                messageStore.getNextMessage(vms.getDeviceStatus().lmessage).ifPresent(message ->
                {
                    BoardDocument document = message.document;
                    
                    boolean width = w < document.width * 1.25f;
                    boolean height = h < document.height * 1.25f;
                    
                    if (width || height)
                    {
                        BufferedImage image = document.getBufferedImage();
                        g2.drawImage(image.getScaledInstance((int) shape.getBounds2D().getWidth(), (int) shape.getBounds2D().getHeight(), Image.SCALE_FAST), (int) shape.getBounds2D().getX(), (int) shape.getBounds2D().getY(), null);
                    } else
                    {
                        BufferedImage image = document.getRealisticImage((int)shape.getBounds2D().getWidth(), (int)shape.getBounds2D().getHeight(), true);
                        
                        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
                        g2.drawImage(image, (int) shape.getBounds2D().getX(), (int) shape.getBounds2D().getY(), null);
                        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
                        
                    }
                });
            }
        }
    }
    
    public class VmsMessageStorage
    {
        private List<VmsGeneralStatusMessage> lMessage;
        private long currentMessageTimestamp = 0;
        private VmsGeneralStatusMessage currentMessage;
        
        public Optional<VmsGeneralStatusMessage> getNextMessage(List<VmsGeneralStatusMessage> currentMessages)
        {
            checkMessageList(currentMessages);
            
            Optional<VmsGeneralStatusMessage> messageOpt = Optional.empty();
            
            if(lMessage.isEmpty())
                return messageOpt;
            
            if(currentMessage == null)
            {
                messageOpt = Optional.of(lMessage.get(0));
                currentMessageTimestamp = System.currentTimeMillis();
                currentMessage = messageOpt.get();
            }
            else
            {
                if((System.currentTimeMillis() - currentMessageTimestamp) >= currentMessage.time * 1000)
                {
                    currentMessageTimestamp = System.currentTimeMillis();
                    
                    int messageIndex = lMessage.indexOf(currentMessage);
                    
                    int nextIndex = messageIndex >= lMessage.size() - 1  ? 0 : messageIndex + 1 ;
                    
                    currentMessage = lMessage.get(nextIndex);
                }
                
                messageOpt = Optional.of(currentMessage);
            }
            
            return messageOpt;
        }
        
        private void checkMessageList(List<VmsGeneralStatusMessage> currentMessages)
        {
            try
            {
                if (!Serialization.equals(currentMessages, lMessage))
                {
                    lMessage = currentMessages;
                    currentMessage = null;
                }
            }
            catch (Exception ex){}
        }
    }
//</editor-fold>

}