#ifndef Model2D_H
#define Model2D_H

#include <functional>

#include "Array.h"
#include "DreieckListe.h"
#include "Punkt.h"
#include "Vec3.h"
#include "Welt2D.h"
#include "Zeichnung.h"

namespace Framework
{
    class Textur2D;

    //! Eine Polygon Struktur, die von Model2D verwendet wird
    //! Model2D Klasse löscht die Zeiger
    struct Polygon2D
    {
        bool transparent;
        Text* name;
        Array<Vertex>* vertex;
        Array<Vertex>* tKordinaten;
        Vertex* schwerpunkt;
    };

    //! Die Daten für ein 2D Model
    class Model2DData : public virtual ReferenceCounter
    {
    private:
        RCArray<Array<Punkt>> outList;

        //! Überprüft, ob ein Punkt im Model ist
        //! \param p Der Punkt
        //! \param polygonId Die Id des Polygons, das geprüft werden soll
        bool istPunktInnen(Vertex p, int polygonId = -1) const;
        //! Überprüft, ob eine Linie innerhalb des Models ist
        //! \param a Der Startpunkt der Linie
        //! \param b Der Endpunkt der Linie
        bool istLinieInnen(Vertex a, Vertex b, int polygonId = -1) const;

    public:
        Array<Polygon2D>* polygons;
        RCArray<RCArray<DreieckListe<Vertex>>>* vListen;
        Punkt minP, maxP;

        //! Konstruktor
        __declspec(dllexport) Model2DData();
        //! Destruktor
        __declspec(dllexport) ~Model2DData();
        //! Erstellt die Dreieck Listen anhand aller gegebenen Eckpunkte der
        //! Polygons \param polygons Ein Array von Polygons \return gibt immer 1
        //! zurück
        __declspec(dllexport) bool erstelleModell(Array<Polygon2D>* polygons);
        //! Löscht die erstellten Dreiecklisten und die Eckpunkte
        __declspec(dllexport) void removeModell();
        //! gibt das polygon mit einem bestimmten namen zurück
        //! \param pos Der Stützvektor der Linie
        //! \param dir Der richtungsvektor der Linie
        //! \param polygonName Der Name des polygons mit dem der schnittpunkt
        //! berechnet werden soll \param hitPoint eine referenz auf die variable
        //! in dem der schnittpunkt gespeichert werden soll \param moveSpeed die
        //! aus der Krafteinwirkung resultierende bewegungsgeschwindigkeit
        //! \param rotSpeed die aus der Krafteinwirkung resultierende
        //! drehgeschwindigkeit \return 1, fals ein Schnittpunkt existiert
        __declspec(dllexport) bool calcHitPoint(Vertex pos,
            Vertex dir,
            const char* polygonName,
            Vertex& hitpoint,
            Vertex& moveSpeed,
            float& rotSpeed) const;
        //! Teil ein bestimmtes polygon in zwei teile
        //! \param pos Startposition des risses
        //! \param dir Startrichtung des risses
        //! \param polygonName der Name des Polygons
        //! \param partA ein Zeiger auf ein Model2DData objekt, in dem die eine
        //! hälfte gespeichert werden soll (ausgabe) \param partB ein Zeiger auf
        //! ein Model2DData objekt, in dem die andere hälfte gespeichert werden
        //! soll (ausgabe) \param posA die Position des einen neuen Polygons
        //! (ausgabe) \param posB die Position des anderen neuen Polygons
        //! (ausgabe) \param random eine funktion die zufällige werte zurückgibt
        __declspec(dllexport) bool split(Vertex pos,
            Vertex dir,
            char* polygonName,
            Polygon2D& partA,
            Polygon2D& partB,
            Punkt& posA,
            Punkt& posB,
            std::function<double()> random) const;
        //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht
        //! transparenten Polygone)
        __declspec(dllexport) float getMasse() const;
    };

    class Model2DObject : public Object2D
    {
    private:
        Model2DData* rData;
        RCArray<Textur2D>* textur;

    public:
        //! Konstruktor
        __declspec(dllexport) Model2DObject();
        //! Destruktor
        __declspec(dllexport) virtual ~Model2DObject();
        //! Setzt die Daten des Models
        //! \param mdl Die Model Daten
        __declspec(dllexport) void setModel(Model2DData* mdl);
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        __declspec(dllexport) void setTextur(Textur2D* t);
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        //! \param polygonName Der name des Polygons, was die Textur bekommen
        //! soll
        __declspec(dllexport) void setTextur(
            Textur2D* t, const char* polygonName);
        __declspec(dllexport) void impuls(
            Vertex start, Vertex speed, float strength = 1.f) override;
        //! Zeichnet die Zeihnung in ein bestimmtes Bild
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        __declspec(dllexport) void render(
            Mat3<float>& kamMat, Bild& zRObj, const char* kamName) override;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen
        //! mit transparenten polygonen beachtet
        __declspec(dllexport) bool istPunktInnen(
            Vertex p, bool ignoreTransparent = 0) const override;
        //! Überprüft, ob eine Linie im Model enthalten ist
        //! \param a Der startpunkt der Linie
        //! \param b Der endpunkt der Linie
        //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen
        //! mit transparenten polygonen beachtet
        __declspec(dllexport) bool istLinieInnen(
            Vertex a, Vertex b, bool ignoreTransparent = 0) const override;
        //! Überprüft, ob sich das Objekt mit einem anderen Überschneidet
        //! \param zObj Ein Zeiger auf das andere Objekt ohne erhöhten Reference
        //! Counter \param sp Ein Zeiger auf einen Punkt, in dem der
        //! Schnittpunkt gespeichert wird \param end 0, falls alle Ecken beider
        //! Objekte überprüft werdden sollen. 1, falls nur die Punkte dieses
        //! Models im anderen gesucht werden sollen \param ignoreTransparentFlag
        //! wenn 1, dann werden auch collisionen mit transparenten polygonen
        //! beachtet
        __declspec(dllexport) virtual bool istModelInnen(const Object2D* zObj,
            Vertex* sp = 0,
            bool end = 0,
            bool ignoreTransparent = 0) const;
        __declspec(dllexport) Rect2<float> getBoundingBox() const override;
        //! Bestimmt den Aufschlagspunkt eines Strahls, der von pos ausgehend in
        //! Richtung dir abgegeben wird. \param pos Der Stützvektor der Linie
        //! \param dir Der richtungsvektor der Linie
        //! \param hitPoint eine referenz auf die variable in dem der
        //! schnittpunkt gespeichert werden soll \return 1, fals ein
        //! Schnittpunkt existiert
        __declspec(dllexport) bool calcHitPoint(
            Vertex pos, Vertex dir, Vertex& hitpoint) const override;
        __declspec(dllexport) float getLuftWiederstand() const override;
        //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht
        //! transparenten Polygone)
        __declspec(dllexport) float getMasse() const override;
        //! Gibt die Textur des ersten Polygons zurück
        __declspec(dllexport) Textur2D* getTextur() const;
        //! Gibt die Textur eines Polygons zurück
        //! \param polygonName Der Name des Polygons
        __declspec(dllexport) Textur2D* getTextur(
            const char* polygonName) const;
        //! Gibt die Textur des ersten Polygons ohne erhöhten Reference Counter
        //! zurück
        __declspec(dllexport) Textur2D* zTextur() const;
        //! Gibt die Textur eines Polygons ohne erhöhten Reference Counter
        //! zurück \param polygonName Der Name des Polygons
        __declspec(dllexport) Textur2D* zTextur(const char* polygonName) const;
        //! Gibt die Model Daten zurück
        __declspec(dllexport) Model2DData* getModel() const;
        //! Gibt die Model Daten ohne erhöhten Reference Counter zurück
        __declspec(dllexport) Model2DData* zModel() const;
    };

    //! Eine Zeichnung von einem Model
    class Model2D : public Zeichnung
    {
    public:
        class Style : public Zeichnung::Style
        {
        public:
            static const __int64 Textur
                = 0x8; //! Wenn dieser Flag gesetzt ist, wird beim Zeichnen eine
                       //! Textur verwendet
            static const __int64 Rahmen
                = 0x10; //! Wenn dieser Flag gesetzt ist, werden die Render der
                        //! Polygone gezeichnet
            static const __int64 Alpha
                = 0x40; //! Wenn dieser Fag gesetzt ist, wird beim Zeichnen
                        //! alphablending verwendet
            static const __int64 Mesh
                = 0x20; //! Wenn dieser Flag gesetzt ist, werden die Render der
                        //! Dreiecke gezeichnet
        };

    private:
        Model2DData* rData;
        float drehung;
        float size;
        int farbe;
        RCArray<Textur2D>* textur;

    public:
        //! Konstruktor
        __declspec(dllexport) Model2D();
        //! Destruktor
        __declspec(dllexport) virtual ~Model2D();
        //! Setzt die Daten des Models
        //! \param mdl Die Model Daten
        __declspec(dllexport) void setModel(Model2DData* mdl);
        //! Setzt die Drehung des Models gegen den Uhrzeigersinn
        //! \param drehung Der winkel in Bogenmas
        __declspec(dllexport) void setDrehung(float drehung);
        //! Fügt zum aktuellen Drehungswinkel etwas hinzu
        //! \param drehung Der Winkel in Bogenmas, der hinzugefügt werden soll
        __declspec(dllexport) void addDrehung(float drehung);
        //! Setzt die Skallierung des Modells
        //! \param size Der Faktor, mit dem Skalliert wird
        __declspec(dllexport) void setSize(float size);
        //! Addiert zur Skallierung einen bestimmten Wert hinzu
        //! \param size Der Wert, der zur skallierung hinzugefügt werden soll
        __declspec(dllexport) void addSize(float size);
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        __declspec(dllexport) void setTextur(Textur2D* t);
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        //! \param polygonName Der name des Polygons, was die Textur bekommen
        //! soll
        __declspec(dllexport) void setTextur(
            Textur2D* t, const char* polygonName);
        //! Setzt die Farbe
        //! \param f Die Farbe im A8R8G8B8 Format
        __declspec(dllexport) void setFarbe(int f);
        //! Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion
        //! vergangen ist \param tickVal Die vergangene Zeit in Sekunden
        __declspec(dllexport) bool tick(double tickVal) override;
        //! Zeichnet die Zeihnung in ein bestimmtes Bild
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        __declspec(dllexport) void render(Bild& zRObj) override;
        //! gibt die Drehung des Models zurück
        __declspec(dllexport) float getDrehung() const;
        //! gibt den Skallierungs Faktor zurück
        __declspec(dllexport) float getSize() const;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        __declspec(dllexport) bool istPunktInnen(int x, int y) const override;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        __declspec(dllexport) bool istPunktInnen(Vertex p) const;
        //! Überprüft, ob eine Linie im Model enthalten ist
        //! \param a Der startpunkt der Linie
        //! \param b Der endpunkt der Linie
        __declspec(dllexport) bool istLinieInnen(Vertex a, Vertex b) const;
        //! Überprüft, ob sich das Model mit einem anderen Überschneidet
        //! \param zMdl Ein Zeiger auf das andere Model ohne erhöhten Reference
        //! Counter \param end 0, falls alle Ecken beider Modele überprüft
        //! werdden sollen. 1, falls nur die Punkte dieses Models im anderen
        //! gesucht werden sollen
        __declspec(dllexport) bool istModelInnen(
            const Model2D* zMdl, bool end = 0) const;
        //! Gibt die Model Daten zurück
        __declspec(dllexport) Model2DData* getModel() const;
        //! Gibt die Model Daten ohne erhöhten Reference Counter zurück
        __declspec(dllexport) Model2DData* zModel() const;
    };
} // namespace Framework
#endif