#pragma once

#include "EditorKlient.h"
#include <Punkt.h>
#include <Critical.h>
#include <functional>
#include <Welt2D.h>
#include <Model2D.h>
#include <GSLDateiV.h>
#include "Model.h"
#include "Variablen.h"
#include "Trigger.h"

namespace Editor
{
    struct TeamDaten : public Model
    {
        int id;
        int maxWbzeit;
        int punkte;

        TeamDaten();
        TeamDaten( const TeamDaten &daten );
    };

    struct SpielerDaten : public Model
    {
        int id;
        Punkt spawn;

        SpielerDaten();
        SpielerDaten( const SpielerDaten &daten );
    };

    struct BariereDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;
        int style;
        int verschiebungWeite;
        int autoSchaltungMaxTime;
        int team;

        BariereDaten();
        BariereDaten( const BariereDaten &daten );
    };

    struct BaseDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;
        int maxTime;
        int team;
        bool showTimer;
        Punkt timer;
        int timerFarbe;

        BaseDaten();
        BaseDaten( const BariereDaten &daten );
    };

    struct DropDaten : public Model
    {
        int id;
        Punkt minPos;
        Punkt maxPos;
        int maxTime;
        int numDrops;
        float wahrscheinlichkeit[ ITEMANZAHL ];
        Text name;

        DropDaten();
        DropDaten( const BariereDaten &daten );
    };

    struct SchalterDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;
        bool aktiv;

        SchalterDaten();
        SchalterDaten( const BariereDaten &daten );
    };

    struct SchieneDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;

        SchieneDaten();
        SchieneDaten( const BariereDaten &daten );
    };

    struct TimerDaten : public Model
    {
        int id;
        Punkt pos;
        int maxZeit;
        bool sichtbar;
        bool autoWiederhohlung;
        bool runns;
        int farbe;
        Text name;

        TimerDaten();
        TimerDaten( const BariereDaten &daten );
    };

    struct TunnelDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;
        Punkt ziel;
        bool aktiv;

        TunnelDaten();
        TunnelDaten( const BariereDaten &daten );
    };

    struct UmlenkungDaten : public Model
    {
        int id;
        Punkt pos;
        Punkt size;
        char richtung;
        int maxAbklingzeit;
        bool drehend;
        bool aktiv;

        UmlenkungDaten();
        UmlenkungDaten( const BariereDaten &daten );
    };

    struct TriggerDaten : public Model
    {
        int id;
        Text name;
        Array< EreignisTyp > *ereignisse;
        RCArray< Bedingung > *bedingungen;
        RCArray< Aktion > *aktionen;

        TriggerDaten();
        TriggerDaten( const BariereDaten &daten );
        ~TriggerDaten();
    };

    struct VariableDaten : public Model
    {
        Text oldName;
        Text name;
        Variable *var;

        VariableDaten();
        VariableDaten( const BariereDaten &daten );
        ~VariableDaten();
    };

    class EditorObject : public ZeichnungHintergrund
    {
    public:
        enum ObjektTyp
        {
            SPIELER,
            BARIERE,
            BASE,
            BASE_TIMER,
            SCHALTER,
            SCHIENE,
            TIMER,
            TUNNEL,
            TUNNEL_ZIEL,
            UMLENKUNG
        };

    private:
        ObjektTyp typ;
        int id;

    public:
        EditorObject( ObjektTyp typ, int id );
        virtual ~EditorObject();
        virtual void update() = 0;
        bool isObjekt( ObjektTyp typ, int id );
    };

    class EdSpieler : public EditorObject
    {
    private:
        SpielerDaten *mdl;

    public:
        EdSpieler( SpielerDaten *model );
        ~EdSpieler();
        void update();
    };

    class EdBariere : public EditorObject
    {
    private:
        BariereDaten *mdl;

    public:
        EdBariere( BariereDaten *model );
        ~EdBariere();
        void update();
    };

    class EdBase : public EditorObject
    {
    private:
        BaseDaten *mdl;

    public:
        EdBase( BaseDaten *model );
        ~EdBase();
        void update();
    };

    class EdBaseTimer : public EditorObject
    {
    private:
        BaseDaten *mdl;

    public:
        EdBaseTimer( BaseDaten *model );
        ~EdBaseTimer();
        void update();
    };

    class EdDrop : public EditorObject
    {
    private:
        DropDaten *mdl;

    public:
        EdDrop( DropDaten *model );
        ~EdDrop();
        void update();
    };

    class EdSchalter : public EditorObject
    {
    private:
        SchalterDaten *mdl;

    public:
        EdSchalter( SchalterDaten *model );
        ~EdSchalter();
        void update();
    };

    class EdSchiene : public EditorObject
    {
    private:
        SchieneDaten *mdl;

    public:
        EdSchiene( SchieneDaten *model );
        ~EdSchiene();
        void update();
    };

    class EdTimer : public EditorObject
    {
    private:
        TimerDaten *mdl;

    public:
        EdTimer( TimerDaten *model );
        ~EdTimer();
        void update();
    };

    class EdTunnel : public EditorObject
    {
    private:
        TunnelDaten *mdl;

    public:
        EdTunnel( TunnelDaten *model );
        ~EdTunnel();
        void update();
    };

    class EdTunnelZiel : public EditorObject
    {
    private:
        TunnelDaten *mdl;

    public:
        EdTunnelZiel( TunnelDaten *model );
        ~EdTunnelZiel();
        void update();
    };

    class EdUmlenkung : public EditorObject
    {
    private:
        UmlenkungDaten *mdl;

    public:
        EdUmlenkung( UmlenkungDaten *model );
        ~EdUmlenkung();
        void update();
    };

    class UpdateObserver : public View
    {
    private:
        std::function< void() > f;

    public:
        UpdateObserver( std::function< void() > f );
        void update( Model *m ) override;
    };

    class KarteDaten : public Thread
    {
    private:
        Punkt renderPos;
        EditorKlient *client;
        SpielerTeamStruktur *sts;
        Array< SpielerDaten * > spieler;
        Array< TeamDaten * > teams;
        Array< BariereDaten * > barieren;
        Array< BaseDaten * > basen;
        Array< DropDaten * > drops;
        Array< SchalterDaten * > schalter;
        Array< SchieneDaten * > schienen;
        Array< TimerDaten * > timer;
        Array< TunnelDaten * > tunnel;
        Array< UmlenkungDaten * > umlenkungen;
        Array< TriggerDaten * > trigger;
        Array< VariableDaten * > variablen;
        RCArray< EditorObject > *objects;
        Text error;
        Array< std::function< void() > > aktionen;
        Critical cs;
        Punkt size;
        bool exit;

        void loadSpielResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );

    public:
        KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts );
        ~KarteDaten();
        void addBariere( BariereDaten &daten, std::function< void( int ) > callBack );
        void removeBariere( int index );
        void addBase( BaseDaten &daten, std::function< void( int ) > callBack );
        void removeBase( int index );
        void addDrop( DropDaten &daten, std::function< void( int ) > callBack );
        void removeDrop( int index );
        void addSchalter( SchalterDaten &daten, std::function< void( int ) > callBack );
        void removeSchalter( int index );
        void addSchiene( SchieneDaten &daten, std::function< void( int ) > callBack );
        void removeSchiene( int index );
        void addTimer( TimerDaten &daten, std::function< void( int ) > callBack );
        void removeTimer( int index );
        void addTunnel( TunnelDaten &daten, std::function< void( int ) > callBack );
        void removeTunnel( int index );
        void addUmlenkung( UmlenkungDaten &daten, std::function< void( int ) > callBack );
        void removeUmlenkung( int index );
        void addTrigger( TriggerDaten &daten, std::function< void( int ) > callBack );
        void removeTrigger( int index );
        void addVariable( VariableDaten &daten, std::function< void( int ) > callBack );
        void removeVariable( int index );
        void thread() override;
        void doPublicMausEreignis( MausEreignis &me );
        void doTastaturEreignis( TastaturEreignis &te );
        bool tick( double tickVal );
        void render( Bild &rObj );
        BariereDaten *getBariere( int index );
        BaseDaten *getBase( int index );
        DropDaten *getDrop( int index );
        SchalterDaten *getSchalter( int index );
        SchieneDaten *getSchiene( int index );
        TimerDaten *getTimer( int index );
        TunnelDaten *getTunnel( int index );
        UmlenkungDaten *getUmlenkung( int index );
        TriggerDaten *getTrigger( int index );
        VariableDaten *getVariable( int index );
        SpielerDaten *getSpieler( int index );
        TeamDaten *getTeam( int index );
        const char *getTeamName( int index );
        int getSpielerIndexById( int id );
        int getSpielerAnzahl() const;
        int getTeamIndexById( int id );
        int getTeamAnzahl() const;
        int getBariereIndexById( int id );
        int getBariereAnzahl() const;
        int getBaseIndexById( int id );
        int getBaseAnzahl() const;
        int getDropIndexById( int id );
        int getDropAnzahl() const;
        int getSchalterIndexById( int id );
        int getSchalterAnzahl() const;
        int getSchieneIndexById( int id );
        int getSchieneAnzahl() const;
        int getTimerIndexById( int id );
        int getTimerAnzahl() const;
        int getTunnelIndexById( int id );
        int getTunnelAnzahl() const;
        int getUmlenkungIndexById( int id );
        int getUmlenkungAnzahl() const;
        int getTriggerIndexById( int id );
        int getTriggerAnzahl() const;
        int getVariableIndexByName( Text name );
        int getVariableAnzahl() const;
        bool hasError() const;
        char *getError() const;
        bool hasAktions() const;
    };
}