package Parking;


import art.library.model.devices.Device;
import art.library.model.devices.DeviceCommands;
import art.library.model.devices.DeviceGraphicsRuntime;
import art.library.model.devices.DeviceStatus;
import com.kitfox.svg.SVGDiagram;



public class Group extends DeviceGraphicsRuntime
{

    public Group(art.library.model.devices.Device device, SVGDiagram diagram)
    {
        super(device, diagram);
    }

    public void status()
    {
        getElementsContainingField("art.signal").stream().forEach(this::processSignal);
        getElementsContainingField("art.signal.required").stream().forEach(this::processRequiredSignal);
        getElementsContainingField("art.binary.signal").stream().forEach(this::processBinaryInout);
        getElementsContainingField("art.gauge").stream().forEach(this::processGauge);
        getElementsContainingField("art.horizontalbar.signal").stream().forEach(this::processHorizontalBar);
        getElementsContainingField("art.verticalbar.signal").stream().forEach(this::processVerticalBar);
        getElementsContainingField("art.translate").stream().forEach(this::translateTexts);
    }

    private void processVerticalBar(com.kitfox.svg.SVGElement element)
    {
        try
        {
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            setAttribute(element, "y", 0);
            setAttribute(element, "height", 0);
            if (device.isPresent())
            {
                art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.verticalbar.signal"));
                com.kitfox.svg.SVGElement topReference = getElement(getAttribute(element, "art.top.reference"));
                com.kitfox.svg.SVGElement bottomReference = getElement(getAttribute(element, "art.bottom.reference"));
                float signalValue = (float) Float.valueOf(signal.value);
                float maxValue = topReference.getPresAbsolute("art.value").getFloatValue();
                float minValue = bottomReference.getPresAbsolute("art.value").getFloatValue();
                if (minValue < 0)
                {
                    signalValue += (minValue * -1);
                    maxValue += (minValue * -1);
                    minValue = 0;
                }
                float topYCoord = topReference.getPresAbsolute("y").getFloatValue();
                float bottomYCoord = bottomReference.getPresAbsolute("y").getFloatValue();
                if (signalValue >= minValue)
                {
                    signalValue -= minValue;
                    float totalSteps = Math.abs(topYCoord - bottomYCoord);
                    float stepValue = totalSteps / maxValue;
                    float newValue = (float) (signalValue * stepValue);
                    float newYCoord = bottomYCoord - newValue;
                    float newHeight = Math.abs(newYCoord - bottomYCoord);
                    setAttribute(element, "y", newYCoord);
                    setAttribute(element, "height", newHeight);
                }
            }
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void processHorizontalBar(com.kitfox.svg.SVGElement element)
    {
        try
        {
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            setAttribute(element, "width", 0);
            if (device.isPresent())
            {
                art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.horizontalbar.signal"));
                com.kitfox.svg.SVGElement rightReference = getElement(getAttribute(element, "art.right.reference"));
                com.kitfox.svg.SVGElement leftReference = getElement(getAttribute(element, "art.left.reference"));
                int signalValue = (int) Integer.valueOf(signal.value);
                int maxValue = rightReference.getPresAbsolute("art.value").getIntValue();
                int minValue = leftReference.getPresAbsolute("art.value").getIntValue();
                int rightXCoord = rightReference.getPresAbsolute("x").getIntValue();
                int leftXCoord = element.getPresAbsolute("x").getIntValue();
                if (signalValue >= minValue)
                {
                    signalValue -= minValue;
                    float totalSteps = Math.abs(rightXCoord - leftXCoord);
                    float stepValue = totalSteps / (maxValue - minValue);
                    int newValue = (int) (signalValue * stepValue);
                    setAttribute(element, "width", newValue);
                }
            }
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void processGauge(com.kitfox.svg.SVGElement element)
    {
        try
        {
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            if (!device.isPresent())
            {
                return;
            }
            final int initAngle = 255;
            final int endAnggle = 520;
            final float maxValue = element.getPresAbsolute("art.gauge.maxvalue").getFloatValue();
            final float minValue = element.getPresAbsolute("art.gauge.minvalue").getFloatValue();
            final float availableRange = Math.abs(initAngle - endAnggle);
            art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.gauge"));
            float signalValue = Float.valueOf(signal.value);
            if (signalValue > maxValue || signalValue < minValue)
            {
                signalValue = 0;
            }
            com.kitfox.svg.SVGElement pivot_reference = getElement(getAttribute(element, "art.gauge.reference"));
            float newAngle = (availableRange / maxValue) * signalValue;
            float cy = pivot_reference.getPresAbsolute("cy").getFloatValue();
            float cx = pivot_reference.getPresAbsolute("cx").getFloatValue();
            String transform = "rotate(%angle,%cx,%cy)".replace("%angle", String.valueOf(initAngle + newAngle)).replace("%cx", String.valueOf(cx)).replace("%cy", String.valueOf(cy));
            setAttribute(element, "transform", transform);
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void processBinaryInout(com.kitfox.svg.SVGElement element)
    {
        try
        {
            final String falseColor = "#808080";
            final String trueColor = "#ff5a00";
            com.kitfox.svg.SVGElement backgroundElement = element.getChild(0);
            com.kitfox.svg.SVGElement textElement = element.getChild(1);
            setAttribute(backgroundElement, "fill", falseColor);
            setText(textElement, "?");
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            if (device.isPresent())
            {
                art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.binary.signal"));
                setAttribute(backgroundElement, "fill", "false".equals(signal.value) ? falseColor : trueColor);
                setText(textElement, "");
            }
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void processSignal(com.kitfox.svg.SVGElement element)
    {
        try
        {
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            if (!device.isPresent())
            {
                setText(element, "");
            } else
            {
                art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.signal"));
                String value = signal.value;
                if (element.hasAttribute("art.units", com.kitfox.svg.animation.AnimationElement.AT_AUTO))
                {
                    value += signal.units;
                } else if (element.hasAttribute("art.timestamp", com.kitfox.svg.animation.AnimationElement.AT_AUTO))
                {
                    value = getTimeddHHMMSS(Long.valueOf(value));
                }
                setText(element, value);
            }
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void processRequiredSignal(com.kitfox.svg.SVGElement element)
    {
        try
        {
            java.util.Optional<art.library.model.devices.signalsboard.SignalsBoard> device = getDeviceOpt();
            if (!device.isPresent())
            {
                setText(element, "");
            } else
            {
                art.library.model.devices.signalsboard.status.SignalStatus signal = device.get().getDeviceStatus().getSignal(getAttribute(element, "art.signal.required"));
                String value = signal.value;
                String requiredValue = getAttribute(element, "art.signal.required.value");
                setAttribute(element, "fill", value.equals(requiredValue) ? "#34c734" : "#dddddd", 999);
            }
            update(element);
        } catch (Exception ex)
        {
        }
    }

    private void translateTexts(com.kitfox.svg.SVGElement element)
    {
        try
        {
            setText(element, art.client.models.Shared.getMessage(getText(element)));
        } catch (Exception ex)
        {
        }
    }

    private <T extends Device> java.util.Optional<T> getDeviceOpt()
    {
        java.util.Optional<T> deviceOpt = java.util.Optional.empty();
        try
        {
            com.kitfox.svg.SVGElement metadata = getElement("Metadata");
            String deviceIdentifier = getAttribute(metadata, "art.device");
            deviceOpt = java.util.Optional.of((T) art.client.models.Shared.model.modelDevices.getDevice(deviceIdentifier));
        } catch (Exception ex)
        {
        }
        return deviceOpt;
    }

    private String getTimeddHHMMSS(long timestamp)
    {
        java.text.DecimalFormat format = new java.text.DecimalFormat("00");
        timestamp = timestamp * 1000;
        if (timestamp < 0)
        {
            return "";
        }
        long difference = timestamp;
        int dias = (int) (difference / 86400000L);
        int horas = (int) ((difference - (dias * 86400000L)) / 3600000L);
        int minutos = (int) ((difference - (dias * 86400000L) - (horas * 3600000L)) / 60000L);
        int segundos = (int) ((difference - (dias * 86400000L) - (horas * 3600000L) - (minutos * 60000L)) / 1000L);
        String result = "";
        result = result + format.format(minutos) + ":";
        result = result + format.format(segundos);
        return result.trim();
    }
}