import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.awt.Color; 
/**
 * Write a description of class Bar here.
 * 
 * @author Marek Parucha
 * @version 2.0_15.03.2014
 */
public class Bar extends Actor
{
    
			/**Breite der Bar*/
            private int barWidth = 30;
			
			/**Höhe der Bar*/
            private int barHeight = 4;
			
			/**Prozent Wert bei dem die Farbe umschlägt*/
            private int breakPercent = 50;
            private int breakValue = 50; // Der Wert bei dem die Farbe umschlägt
            private boolean usingBreakValue = false; // falls true --> breakValue wird verwendet statt breakPercent
            private boolean breakLow = true; // falls true --> farbe schlägt um falls breakPercent oder breakValue erreicht sind
            private Color backgroundColor = new Color(160, 160, 160, 160); // Hintergrund Farbe der gesamten Bar
            private Color textColor = Color.BLACK; // Farbe des Textes
            private Color safeColor = Color.GREEN; // Farbe der Bar falls sie über dem breakPercent oder breakValue Wert ist
            private Color dangerColor = Color.RED; // Farbe der Bar falls sie unter dem breakPercent oder breakValue Wert ist
        
            private float fontSize = 0.0f; // Größe des textes
            private int value = 100; // der jetzige Wert der Bar
            private int maximumValue = 100; // der maximale Wert der Bar
            private int minimumValue = 0; // der minimale Wert der Bart
            private String referenceText = "leben"; // String was diese Bar anzeigt
            private String unitOfMeasure = "%"; // Einheit der Bar
            private boolean showTextualUnits = true; // falls true --> Text wird angezeigt
            
            /**
             * Bar Constructor: Lebensanzeige als Bar
             *
             * @param 'refText': String Text der den Namen dieser Bar angibt
             * @param 'unitType': String Text der Einheiten die Angezeigt werden sollen ("Prozent", "Punkte")
             * @param 'initValue': AnfangsWert der Bar
             * @param 'maxValue': Der höchste Wert der die Bar annehmen kann
             */
            public Bar(String refText, String unitType, int initValue, int maxValue)
            {
                referenceText = refText;
                unitOfMeasure = unitType;
                maximumValue = maxValue;
                add(initValue);
            }
            
            /**
             * Methode 'newImage': Bildet und aktualisiert das Bild der Bar
             */
            private void newImage()
            {
                int barValue = (int) (barWidth * (value - minimumValue) / (maximumValue - minimumValue));
                GreenfootImage leftImg = new GreenfootImage(referenceText + " ", (int) fontSize, textColor, backgroundColor);
                GreenfootImage rightImg = (showTextualUnits) ? new GreenfootImage(" " + value + " " + unitOfMeasure, (int) fontSize, textColor, backgroundColor) : new GreenfootImage(1, 1);
                int maxX = (leftImg.getWidth() > rightImg.getWidth()) ? leftImg.getWidth() : rightImg.getWidth();
                GreenfootImage barImg = new GreenfootImage(barWidth + 4, barHeight + 4);
                barImg.setColor(backgroundColor);
                barImg.fill();
                barImg.setColor(textColor);
                barImg.drawRect(0, 0, barImg.getWidth() - 1, barImg.getHeight() - 1);
                if (value > minimumValue)
                {
                    if (breakLow)
                    {
                        if (value > (usingBreakValue ? breakValue : (int) (breakPercent * (maximumValue - minimumValue) / 100 + minimumValue))) barImg.setColor(safeColor);
                        else barImg.setColor(dangerColor);
                    }
                    else
                    {
                        if (value < (usingBreakValue ? breakValue : (int) (breakPercent * (maximumValue - minimumValue) / 100 + minimumValue))) barImg.setColor(safeColor);
                        else barImg.setColor(dangerColor);
                    }
                    if (value == (usingBreakValue ? breakValue : (int) (breakPercent * (maximumValue - minimumValue) / 100 + minimumValue)))
                    {
                        int r = (int) ((safeColor.getRed() + dangerColor.getRed()) / 2);
                        int g = (int) ((safeColor.getGreen() + dangerColor.getGreen()) / 2);
                        int b = (int) ((safeColor.getBlue() + dangerColor.getBlue()) / 2);
                        barImg.setColor(new Color(r, g, b));
                    }
                    barImg.fillRect(2, 2, barValue, barHeight);
                }
                int sumX = 2 * maxX + barImg.getWidth();
                int maxY = 0;
                if (leftImg.getHeight() > maxY) maxY = leftImg.getHeight();
                if (barImg.getHeight() > maxY) maxY = barImg.getHeight();
                if (rightImg.getHeight() > maxY) maxY = rightImg.getHeight();
                GreenfootImage image = new GreenfootImage(sumX, maxY);
                image.setColor(backgroundColor);
                image.fill();
                image.drawImage(leftImg, maxX - leftImg.getWidth(), (image.getHeight() - leftImg.getHeight()) / 2);
                image.drawImage(barImg, maxX, (image.getHeight() - barImg.getHeight()) / 2);
                //image.drawImage(rightImg, maxX + barImg.getWidth(), (image.getHeight() - rightImg.getHeight()) / 2);
                image.setTransparency(255);
                setImage(image);
            }
            
            /**
             * Methode 'add': Fügt einen Betrag hinzu und aktualisiert mit newImage() das Bild
             *
             * @param 'amount': Der Wert der hinzugefügt werden soll
             */
            public void add(int amount)
            {
                value += amount;
                checkValue();
                newImage();
            }
            
            /**
             * Methode 'subtract': Zieht einen Betrag ab und aktualisiert mit newImage() das Bild
             *
             * @param 'amount': Der Wert der abgezogen werden soll
             */
            public void subtract(int amount)
            {
                value -= amount;
                checkValue();
                newImage();
            }
            
            /**
             * Methode 'checkValue': Kontrolliert ob value noch im Wertebereich ist
             */
            private void checkValue()
            {
                if (value < minimumValue) value = minimumValue;
                if (value > maximumValue) value = maximumValue;
            }
            
            /**
             * Methode 'getValue': gibt den Wert der Bar wieder
             *
             * @return: der Wert der Bar
             */
            public int getValue() { return value; }
            
            
            /**
             * Methode 'setValue': setzt einen Wert für Value der Bar
             *
             * @param 'val': der Wert der Value annehmen soll
             */
            public void setValue(int val) { value = val; checkValue(); newImage(); }
            
            /**
             * Method 'setMaximumValue': setzt den maximalen Wert der Value der Bar
             *
             * @param 'maxVal': der maximale Wert der Value
             */
            public void setMaximumValue(int maxVal) { if (maxVal > minimumValue) { maximumValue = maxVal; newImage(); } }
            
            /**
             * Method 'setMinimumValue': setzt den minimalen Wert der Value der Bar
             *
             * @param 'minVal': der minimale Wert der Value der Bar
             */
            public void setMinimumValue(int minVal) { if (minVal < maximumValue) { minimumValue = minVal; newImage(); } }
    
    
    }    
