#ifndef Schrift_H
#define Schrift_H

#include <functional>

#include "Critical.h"
#include "Punkt.h"
#include "ReferenceCounter.h"

namespace Framework
{
    class Bild;      //! Bild.h
    class Text;      //! Text.h
    class Buchstabe; //! aus dieser Datei
    class Alphabet;  //! aus dieser Datei
    class Schrift;   //! aus dieser Datei

    //! Speichert die Alphawerte eines Zeichens einer bestimmten Schrift
    //! Die anderen Farbwerte werden durch die Schriftfarbe bestimmt. Daher nur
    //! die Alpha werte.
    class Buchstabe : public virtual ReferenceCounter
    {
    private:
        Punkt size;
        unsigned char* alpha;
        int schriftSize;

    public:
        //! Erstellt ein neues leeres Zeichnung
        DLLEXPORT Buchstabe();
        //! Loescht das Zeichnung
        DLLEXPORT ~Buchstabe();
        //! Erstellt einen neuen Buchstaben mit bestimmter Groesse
        //! \param size Die Groesse des Buchstabens in Pixel
        DLLEXPORT void NeuBuchstabe(Punkt& size);
        //! Setzt den Alphawert eines bestimmten Pixels
        //! \param pos Die position des Pixels
        //! \param alpha Der Wert des Pixels
        DLLEXPORT void setPixel(Punkt& pos, unsigned char alpha);
        //! Setzt den Alphawert eines bestimmten Pixels
        //! \param x die x Position des Pixels
        //! \param y die y Position des Pixels
        //! \param alpha Der Wert des Pixels
        DLLEXPORT void setPixel(int x, int y, unsigned char alpha);
        //! Setzt den Alphawert eines bestimmten Pixels
        //! \param i der Index des Pixels. Er berechnet sich durch x + y *
        //! breite und geht von 0 bis breite * hoehe - 1 \param alpha Der Wert
        //! des Pixels
        DLLEXPORT void setPixel(int i, unsigned char alpha);
        //! Setzt die Schriftgroesse, zu der der Buchstabe gehoert
        //! \param sg Die Schriftgroesse des Buchstabens.
        DLLEXPORT void setSchriftSize(int sg);
        //! Gibt die Schriftgroesse zurueck, zu der der Buchstabe gehoert
        DLLEXPORT int getSchriftSize() const;
        //! Gibt die alpha Werte des Buchstabens als array zurueck wobei die
        //! werte Zeilenweise hintereinander stehen
        DLLEXPORT unsigned char* getBuff() const;
        //! Gibt die Groesse des Buchstabens in Pixeln nicht skalliert zurueck.
        DLLEXPORT const Punkt& getSize() const;
        //! Gibt die Breite des Buchstabens in Pixeln zurueck
        DLLEXPORT int getBreite() const;
        //! Gibt die Hoehe des Buchstabens in Pixeln zurueck
        DLLEXPORT int getHeight() const;
    };

    //! Speichert alle Buchstaben der selben Schriftgroesse.
    //! Wird von der Schrift klasse verwendet
    class Alphabet : public virtual ReferenceCounter
    {
    private:
        Buchstabe** zeichen;
        int schriftSize;

    public:
        //! Erzeugt ein leeres Zeichnung
        DLLEXPORT Alphabet();
        //! Loescht ein Zeichnung
        DLLEXPORT ~Alphabet();
        //! Loescht alle gespeicherten Zeichen
        DLLEXPORT void NeuAlphabet();
        //! Fuegt dem Alphabet einen Buchstaben hinzu
        //! Wenn der hinzugefuegte Buchstabe bereits existiert wird er
        //! ueberschrieben \param i Der ASCII code des Buchstaben, der
        //! hinzugefuegt werden soll \param buchstabe Der Buchstabe, der
        //! hinzugefuegt wird
        DLLEXPORT void setBuchstabe(unsigned char i, Buchstabe* buchstabe);
        //! Setzt die Schriftgroesse des Alphabets und die der gespeicherten
        //! buchstaben \param gr Die Schriftgroesse des Alphabets
        DLLEXPORT void setSchriftSize(int gr);
        //! Gibt den gespeicherten Buchstaben zu einem bestimmten ASCII Zeichen
        //! zurueck \param i Der ASCII code des Zeichens \return Ein Zeiger zu
        //! dem Buchstaben mit erhoehtem Reference Counter
        DLLEXPORT Buchstabe* getBuchstabe(unsigned char i) const;
        //! Gibt den gespeicherten Buchstaben zu einem bestimmten ASCII Zeichen
        //! zurueck \param i Der ASCII code des Zeichens \return Ein Zeiger zu
        //! dem Buchstaben ohne erhoehtem Reference Counter
        DLLEXPORT Buchstabe* zBuchstabe(unsigned char i) const;
        //! Prueft, ob zu einem bestimmten ASCII code ein Zeichen vorhanden ist
        //! \param b Der zu pruefende ASCII code
        //! \return (true), wenn ein Zeichen zu dem Code gefunden wurde. (false)
        //! sonnst
        DLLEXPORT bool hatBuchstabe(unsigned char b) const;
        //! Gibt die Schriftgroesse zurueck, deren Zeichen in diesem Alphabet
        //! gespeichert werden
        DLLEXPORT int getSchriftSize() const;
    };

    //! Specihert eine Liste von Alphabeten mit verschiedener Schriftgroesse.
    //! Wird von der Schrift Klasse verwendet, um alle Zeichen der Schriftgroesse
    //! nach sortiert zu speichern.
    class AlphabetArray
    {
    private:
        Alphabet* alphabets[256];

    public:
        //! Erzeugt eine neue Liste
        DLLEXPORT AlphabetArray();

        //! Fuegt der Liste ein Alphabet hinzu
        //! Wenn bereits ein Alphabet mit der selben Schriftgroesse existiert,
        //! wird das Alphabet nicht hinzugefuegt \param alphabet Das Alphabet,
        //! welches hinzugefuegt werden soll \return (true), wenn das Alphabet
        //! hinzugefuegt wurde. (false) sonnst.
        DLLEXPORT bool addAlphabet(Alphabet* alphabet);
        //! Loescht ein Alphabet bestimmter Schriftgroesse aus der Liste
        //! \param sg Die Schriftgroesse des Alphabets, welches entfernt werden
        //! soll \return (true), wenn ein Alphabet entfernt wurde. (false)
        //! sonnst
        DLLEXPORT bool removeAlphabet(unsigned char sg);

        //! Gibt ein bestimmtes Alphabet mit erhoehtem Reference Counter zurueck
        //! \param sg Die Schriftgroesse, dessen Alphabet gesucht werden soll
        //! \return (0), fals kein passendes Alphabet gefunden wurde
        DLLEXPORT Alphabet* getAlphabet(unsigned char sg) const;
        //! Gibt ein bestimmtes Alphabet ohne erhoehtem Reference Counter zurueck
        //! \param sg Die Schriftgroesse, dessen Alphabet gesucht werden soll
        //! \return (0), fals kein passendes Alphabet gefunden wurde
        DLLEXPORT Alphabet* zAlphabet(unsigned char sg) const;
    };

    //! Speichert alle Buchstaben einer Schrift in verschiedenen Schriftgroessen
    class Schrift : public virtual ReferenceCounter
    {
    private:
        unsigned char alphabetAnzahl;
        AlphabetArray* alphabet;

    public:
        //! Erzeugt eine leere Schrift
        DLLEXPORT Schrift();
        //! Loescht ein Zeichnung
        DLLEXPORT ~Schrift();
        //! Fuegt der Schrift ein Alphabet hinzu. Sollte bereits ein Alphabet der
        //! selben Schriftgroesse existieren, wird das Alphabet nicht hinzugefuegt
        //! \param alphabet Das Alphabet, welches hinzugefuegt werden soll
        //! \return (true), wenn das Alphabet hinzugefuegt wurde. (false) sonnst
        DLLEXPORT bool addAlphabet(Alphabet* alphabet);
        //! Loescht ein bestimmtes Alphabet aus der Schrift
        //! \param sg Die Schriftgroesse, deren Alphabet entfernt werden soll
        DLLEXPORT void removeAlphabet(unsigned char sg);
        //! Gibt ein bestimmtes Alphabet mit erhoehtem Reference Counter zurueck
        //! \param sg Die Schriftgroesse, dessen Alphabet gesucht werden soll
        //! \return (0), fals kein passendes Alphabet gefunden wurde
        DLLEXPORT Alphabet* getAlphabet(unsigned char sg) const;
        //! Gibt ein bestimmtes Alphabet ohne erhoehtem Reference Counter zurueck
        //! \param sg Die Schriftgroesse, dessen Alphabet gesucht werden soll
        //! \return (0), fals kein passendes Alphabet gefunden wurde
        DLLEXPORT Alphabet* zAlphabet(unsigned char sg) const;
        //! Gibt zurueck, wie viele Alphabete (und damit Schriftgroessen) in der
        //! Schrift enthalten sind
        DLLEXPORT unsigned char getAlphabetAnzahl() const;
    };

    class TextRenderer : public virtual ReferenceCounter
    {
    protected:
        Schrift* s;
        int schriftSize;
        int zeilenAbstand;
        int zeichenAbstand;
        int charWidths[256];
        int charHeights[256];

    public:
        DLLEXPORT TextRenderer();
        DLLEXPORT TextRenderer(Schrift* schrift);
        DLLEXPORT virtual ~TextRenderer();
        DLLEXPORT void setSchriftZ(Schrift* schrift);
        DLLEXPORT Schrift* getSchrift();
        DLLEXPORT Schrift* zSchrift();
        //! Setzt die Schriftgroesse, in der gezeichnet werden soll. Die Schrift
        //! waehlt automatisch das passende Alphabet zum Zeichnen \param sg Die
        //! Schriftgroesse
        DLLEXPORT void setSchriftSize(int sg);
        //! Setzt den Zeilenabstand, der zum zeichnen verwendet werden soll
        //! \param za Der Zeilenabstand zum unteren Ende der darueber liegenden
        //! zeile in Pixeln
        DLLEXPORT void setZeilenAbstand(int za);
        //! Setzt den Zeichenabstand, der zum zeichnen verwendet werden soll
        //! \param za Der Zeichenabstand zum unteren Ende der darueber liegenden
        //! zeile in Pixeln
        DLLEXPORT void setZeichenAbstand(int za);
        //! Fuegt Zeilenumbrueche in den Text ein, so dass er bei einer
        //! vorgegebenen Breite follstaendig angezeigt wird \param zText Der
        //! text, in den die Zeilenumbrueche eingefuegt werden sollen \param
        //! maxBreite Die Breite in Pixeln auf der der Text follstaendig
        //! angezeigt werden soll
        DLLEXPORT virtual void textFormatieren(Text* zText, int maxBreite);
        //! Zeichnet einen Bestimmten Text mit Cursor und einfaerbung auf ein
        //! Bild Nutze (setPosition) und (setDrawSchriftGroesse) um die Position
        //! und die Groesse zu veraendern \param x x position des ersten zeichens
        //! \param y y position des ersten zeichens
        //! \param txt Der Text, der gezeichnet werden soll
        //! \param zRObj Das Bild, auf das gezeichnet werden soll
        //! \param cpos Die position des Cursors im Text
        //! \param cf Die Farbe des Cursors
        //! \param fbeg Die Position des Zeichens im Text, wo die Einfaerbung
        //! beginnen soll. Der Text wird von dort bis zur Cursorposition
        //! eingefaerbt \param ff Die Hintergrund Farbe des eingefaerbten Textes
        //! \param f Eine Funktion die fuer jeden Buchstaben aufgerufen wird und
        //! seine Farbe zurueckgibt
        DLLEXPORT virtual void renderText(int x,
            int y,
            const char* txt,
            Bild& zRObj,
            std::function<int(int, int, int)> f,
            int cpos = -1,
            int cf = 0,
            int fbeg = -1,
            int ff = 0);
        //! Zeichnet einen Bestimmten Text mit Cursor und einfaerbung auf ein
        //! Bild Nutze (setPosition) und (setDrawSchriftGroesse) um die Position
        //! und die Groesse zu veraendern \param x x position des ersten zeichens
        //! \param y y position des ersten zeichens
        //! \param txt Der Text, der gezeichnet werden soll
        //! \param zRObj Das Bild, auf das gezeichnet werden soll
        //! \param cpos Die position des Cursors im Text
        //! \param cf Die Farbe des Cursors
        //! \param fbeg Die Position des Zeichens im Text, wo die Einfaerbung
        //! beginnen soll. Der Text wird von dort bis zur Cursorposition
        //! eingefaerbt \param ff Die Hintergrund Farbe des eingefaerbten Textes
        //! \param f Die Farbe, in der der Text gezeichnet werden soll
        DLLEXPORT virtual void renderText(int x,
            int y,
            const char* txt,
            Bild& zRObj,
            int f,
            int cpos = -1,
            int cf = 0,
            int fbeg = -1,
            int ff = 0);
        //! Zeichnet einen Bestimmten Buchstaben mit einfaerbung auf ein Bild
        //! Nutze (setPosition) und (setDrawSchriftGroesse) um die Position und
        //! die Groesse zu veraendern \param x x position des ersten zeichens
        //! \param y y position des ersten zeichens
        //! \param txt Der Text, der gezeichnet werden soll
        //! \param zRObj Das Bild, auf das gezeichnet werden soll
        //! \param color Die Farbe, in der der Text gezeichnet werden soll
        //! \param underlined 1, falls der Text unterstrichen sein soll
        //! \param selected 1, falls das zeichen eingefaerbt sein soll
        //! \param selectedBackgroundColor Die Hintergrund Farbe des
        //! eingefaerbten Textes
        DLLEXPORT virtual void renderChar(int& x,
            int y,
            char c,
            Bild& zRObj,
            int color,
            bool underlined = 0,
            bool selected = 0,
            int selectedBackgroundColor = 0);
        //! Gibt die Schriftgroesse zurueck, die zum Zeichnen verwendet wird
        DLLEXPORT int getSchriftSize() const;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten Text
        //! vollstaendig darzustellen \param txt Der Text, von dem die Breite in
        //! Pixeln ermitelt werden soll
        DLLEXPORT virtual int getTextBreite(const char* txt) const;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten Text
        //! vollstaendig darzustellen \param txt Der Text, von dem die Hoehe in
        //! Pixeln ermitelt werden soll
        DLLEXPORT virtual int getTextHeight(const char* txt) const;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten
        //! Buchstaben vollstaendig darzustellen \param c Der Buchstabe, von dem
        //! die Breite in Pixeln ermitelt werden soll
        DLLEXPORT virtual int getCharWidth(const char c) const;
        //! Ermittelt, wie viele Pixel maximal benoetigt werden, um einen
        //! Buchstaben vollstaendig darzustellen
        DLLEXPORT virtual int getMaxCharWidth() const;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten Text
        //! vollstaendig darzustellen \param c Der Buchstabe, von dem die Hoehe in
        //! Pixeln ermitelt werden soll
        DLLEXPORT virtual int getCharHeight(const char c) const;
        //! Gibt den Abstand in Pixeln zum unteren Ende der darueber ligenden
        //! Zeile zurueck
        DLLEXPORT int getZeilenAbstand() const;
        //! Gibt den Abstand in Pixeln zum zwischen zwei zeichen auf der x Achse
        //! zurueck
        DLLEXPORT int getZeichenAbstand() const;
        //! Gibt die skallierte Hoehe zurueck, die eine gezeichnete Zeile in
        //! Pixeln benoetigt
        DLLEXPORT int getZeilenHeight() const;
        //! Ermittelt das Zeichen im Text, auf das die Maus zeigt
        //! \param zTxt Der Text, auf den die Maus Zeigt
        //! \param mausX Die X Position der Maus in Pixeln Relativ zur Position
        //! des ersten Zeichens \param mausY Die Y Position der Maus in Pixeln
        //! Relativ zur Position des ersten Zeichens
        DLLEXPORT virtual int textPos(
            const char* txt, int mausX, int mausY) const;
    };

    class GravurTextRenderer : public TextRenderer
    {
    public:
        DLLEXPORT GravurTextRenderer();
        DLLEXPORT GravurTextRenderer(Schrift* schrift);
        DLLEXPORT virtual ~GravurTextRenderer();
        //! Zeichnet einen Bestimmten Buchstaben mit einfaerbung auf ein Bild
        //! Nutze (setPosition) und (setDrawSchriftGroesse) um die Position und
        //! die Groesse zu veraendern \param x x position des ersten zeichens
        //! \param y y position des ersten zeichens
        //! \param txt Der Text, der gezeichnet werden soll
        //! \param zRObj Das Bild, auf das gezeichnet werden soll
        //! \param color Die Farbe, in der der Text gezeichnet werden soll
        //! \param underlined 1, falls der Text unterstrichen sein soll
        //! \param selected 1, falls das zeichen eingefaerbt sein soll
        //! \param selectedBackgroundColor Die Hintergrund Farbe des
        //! eingefaerbten Textes
        DLLEXPORT virtual void renderChar(int& x,
            int y,
            char c,
            Bild& zRObj,
            int color,
            bool underlined = 0,
            bool selected = 0,
            int selectedBackgroundColor = 0) override;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten
        //! Buchstaben vollstaendig darzustellen \param c Der Buchstabe, von dem
        //! die Breite in Pixeln ermitelt werden soll
        DLLEXPORT virtual int getCharWidth(const char c) const override;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten Text
        //! vollstaendig darzustellen \param c Der Buchstabe, von dem die Hoehe in
        //! Pixeln ermitelt werden soll
        DLLEXPORT virtual int getCharHeight(const char c) const override;
    };

    class KursivTextRenderer : public TextRenderer
    {
    public:
        DLLEXPORT KursivTextRenderer();
        DLLEXPORT KursivTextRenderer(Schrift* schrift);
        DLLEXPORT virtual ~KursivTextRenderer();
        //! Zeichnet einen Bestimmten Buchstaben mit einfaerbung auf ein Bild
        //! Nutze (setPosition) und (setDrawSchriftGroesse) um die Position und
        //! die Groesse zu veraendern \param x x position des ersten zeichens
        //! \param y y position des ersten zeichens
        //! \param txt Der Text, der gezeichnet werden soll
        //! \param zRObj Das Bild, auf das gezeichnet werden soll
        //! \param color Die Farbe, in der der Text gezeichnet werden soll
        //! \param underlined 1, falls der Text unterstrichen sein soll
        //! \param selected 1, falls das zeichen eingefaerbt sein soll
        //! \param selectedBackgroundColor Die Hintergrund Farbe des
        //! eingefaerbten Textes
        DLLEXPORT virtual void renderChar(int& x,
            int y,
            char c,
            Bild& zRObj,
            int color,
            bool underlined = 0,
            bool selected = 0,
            int selectedBackgroundColor = 0) override;
        //! Ermittelt, wie viele Pixel benoetigt werden, um einen Bestimmten
        //! Buchstaben vollstaendig darzustellen \param c Der Buchstabe, von dem
        //! die Breite in Pixeln ermitelt werden soll
        DLLEXPORT virtual int getCharWidth(const char c) const override;
    };
} // namespace Framework

#endif