/**
 * SWBild ist eine Klasse, die Graustufenbilder repraesentiert und
 * manipuliert. Die Implementierung erfolgt durch ein einfaches
 * Bildformat: Die Bildpunkte werden in einem zweidimensionalen
 * Array von 'short'-Werten gehalten. Short ist eine Datentyp für
 * ganzzahlige Werte, wie int. Aber Short kann weniger Werte darstellen.
 * Jeder Feldeintrag in einem SWBild kann einen Wert zwischen 0 und 255
 * annehmen. Andere Werte sind unzulaessig.
 * Der Wertebereich [0..255] repraesentiert den Graustufenbereich:
 * 0 fuer Schwarz, 255 fuer Weiss und dazwischenliegende Werte fuer
 * die Grauabstufungen.
 *
 * Beispielmethode 'dunkler': Ein geladenes Bild kann um
 * ein gegebenes 'delta' abgedunkelt werden.
 *
 * @author  Axel Schmolitzky, Petra Becker-Pechau
 * @version 11/2018
 */
class SWBild
{

    // die Bilddaten dieses Bildes, ein Array von Bildpunkten
    private short[][] _bilddaten;

    // die Breite dieses Bildes
    private int _breite;

    // die Hoehe dieses Bildes
    private int _hoehe;

    // Leinwand zur Anzeige
    private Leinwand _leinwand;

    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Benutzer kann interaktiv mit
     * Hilfe eines Dateidialogs die zu ladende Datei auswaehlen.
     */
    public SWBild()
    {
        _bilddaten = BildEinleser.liesBilddaten();
        if (_bilddaten != null)
        {
            aktualisiereBildgroesse(_bilddaten);
            erzeugeLeinwand();
        }
    }

    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Dateiname kann als absoluter
     * oder relativer Pfad uebergeben werden.
     *
     * @param bilddateiName
     *            der Name der Bilddatei
     */
    public SWBild(String bilddateiName)
    {
        _bilddaten = BildEinleser.liesBilddaten(bilddateiName);
        aktualisiereBildgroesse(_bilddaten);
        erzeugeLeinwand();
    }

    /**
     * Dieses Bild um einen Wert abdunkeln.
     *
     * @param delta
     *            Wert der Abdunkelung. Es wird mit dem Betrag von delta gerechnet,
     *            deshalb darf der Parameter sowohl positiv als auch negativ sein.
     */
    public void dunkler(int delta)
    {
        if (delta < 0)
        {
            delta = -delta;
        }

        // Durch alle Bildpunkte gehen und jeden Wert um das Delta verringern:
        for (int y = 0; y < _hoehe; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                punktAbdunkeln(y, x, delta);
            }
        }
        // Neuzeichnen der Bildleinwand, basierend auf den Werten in _bilddaten:
        zeichneBild();
    }

     public void heller(int delta)
    {
        if (delta < 0)
        {
            delta = -delta;
        }

        // Durch alle Bildpunkte gehen und jeden Wert um das Delta verringern:
        for (int y = 0; y < _hoehe; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                punktAufhellen(y, x, delta);
            }
        }
        // Neuzeichnen der Bildleinwand, basierend auf den Werten in _bilddaten:
        zeichneBild();
    }

    /**
     * Den gegebenen Punkt abdunkeln um den in delta übergebenen Wert.
     * Beim Abdunkeln wird der Wert des Bildpunkts reduziert.
     * Der Parameter delta muss ein positiver Wert sein.
     */
    private void punktAbdunkeln(int y, int x, int delta)
    {
        if ((_bilddaten[y][x] - delta) > 0) // Wert darf 0 nicht unterschreiten
        {
            _bilddaten[y][x] = (short) (_bilddaten[y][x] - delta);
        }
        else
        {
            _bilddaten[y][x] = 0;
        }
    }

    private void punktAufhellen(int y, int x, int delta)
    {
        if ((_bilddaten[y][x] + delta) < 255) // Wert darf 0 nicht unterschreiten
        {
            _bilddaten[y][x] = (short) (_bilddaten[y][x] + delta);
        }
        else
        {
            _bilddaten[y][x] = 255;
        }
    }

    /**
     * Dieses Bild invertieren.
     */
    public void invertieren()
    {
        // Durch alle Bildpunkte des Bildes gehen und jeden Wert "invertieren"
        for (int y = 0; y < _hoehe; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                _bilddaten[y][x] = (short) (255 - _bilddaten[y][x]);
            }
        }
        zeichneBild();
    }

    /**
     * Dieses Bild horizontal spiegeln.
     */
    public void horizontalSpiegeln()
    {
        for (int y = 0; y < _hoehe/2; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
               // _bilddaten[y][x] = _bilddaten[_hoehe - 1 - y] [x];
                short tmp =_bilddaten[_hoehe - 1 - y] [x];
                _bilddaten[_hoehe - 1 - y][x] = _bilddaten[y] [x];
                _bilddaten[y][x] = tmp;
            }
        }
        zeichneBild();
    }

    /**
     * Dieses Bild weichzeichnen.
     */
    public void weichzeichnen()
    {
        // HIER FEHLT NOCH WAS
    }

    /**
     * Dieses Bild am Mittelpunkt spiegeln.
     */
    public void punktpiegeln()
    {
        // HIER FEHLT NOCH WAS
    }

    /**
     * Erzeugt bei diesem Bild einen Spot mit Radius r, Mittelpunkt x0,y0 und
     * Beleuchtungsintensitaet i.
     *
     * Das bedeutet, dass alles innerhalb eines  Kreises mit dem Mittelwpunkt x0,y0
     * und dem Radius r alle Bildpunkte um den Wert i aufgehellt werden sollen.
     *
     * Freiwillige Zusatzaufgabe: Ausserhalb von r nimmt die Ausleuchtung linear ab.
     * Wie im wirklichen Leben...
     *
     * @param xo
     *            x-Koordinate des Mittelpunktes
     * @param yo
     *            y-Koordinate des Mittelpunktes
     * @param r
     *            Radius
     * @param i
     *            Beleuchtungsintesitaet
     */
    public void spot(int x0, int y0, int r, short i)
    {
        // HIER FEHLT NOCH WAS
    }

    /**
     * Gib den Wert eines einzelnen Bildpunktes zurueck.
     *
     * @param y
     *            die y-Koordinate des Bildpunktes.
     * @param x
     *            die x-Koordinate des Bildpunktes.
     * @return den Wert des angegebenen Bildpunktes.
     */
    public short gibBildpunkt(int y, int x)
    {
        return _bilddaten[y][x];
    }

    // ==== private Hilfsmethoden ====

    /**
     * Zeichnet das Bild in _bilddaten neu
     */
    private void zeichneBild()
    {
        _leinwand.sichtbarMachen();
        _leinwand.zeichneBild(_bilddaten);
    }

    /**
     * Hoehe und Breite neu berechnen, nachdem die Bilddaten veraendert worden sind.
     */
    private void aktualisiereBildgroesse(short[][] bilddaten)
    {
        _hoehe = bilddaten.length;
        if (_hoehe == 0)
        {
            _breite = 0;
        }
        else
        {
            _breite = bilddaten[0].length;
        }
    }

    /**
     * Erzeuge die Leinwand zur Darstellung und zeige sie an.
     */
    private void erzeugeLeinwand()
    {
        _leinwand = new Leinwand("Bildbetrachter", _breite, _hoehe);

        zeichneBild();
    }
}