#pragma once

#include <cppconn/driver.h>
#include <mysql_connection.h>
#include <cppconn/exception.h>
#include <cppconn/resultset.h>
#include <cppconn/statement.h>
//#include <cppconn/sqlstring.h>

#include "art.h"
#include "kosten.h"
#include "variablekosten.h"
#include "pixel.h"
#include "massnahme.h"
#include "gruenland.h"
#include "ergebnis.h"
#include "verfahren_ertrag.h"
#include "wuchshoehe.h"
#include "modell.h"
/*#include "driver.h"
 #include "mysql_connection.h"
 #include "exception.h"
 #include "resultset.h"
 #include "statement.h"*/
#include <vector>

using namespace sql;
using namespace std;
/*
 #define DBHOST "tcp://160.45.41.29:3306"
 #define USER "sokobio"
 #define PASSWORD "wee6Jees"
 #define DATABASE "sokobio_leipzig" 
 */

class datenbank
{
public:
    Connection *con;
    datenbank( void);
    ~datenbank( void);
    Connection* datacon( void);

    int insertdata( string table, string column, string value);
    int deletedata( string table, string column, string value);
    int deleteart( string name, string savetime);
    int saveart( art& newart);
    void save_gruenland_for_art( vector< int> gruenlandID, int artID);
    void get_gruenland_for_art( vector< gruenland>& gruen, int artID);
    list< CString> returndata(
            string table,
            string column1,
            string column,
            string value);
    art returnart(
            string table,
            string column1,
            string column2,
            string value1,
            string value2);
    vector< CString> returnartname( string column);
    CString returnname( string column, string column2, CString value);
    vector< CString> returnartspeicherdatum( CString value, string column);
    vector< art*> returnartliste( string table, string column1, string value1);
    void returnvariablekosten(
            int verfahren_nr,
            vector< variablekosten>& varkost);
    verfahren_ertrag returnverfahrenkosten( int verfahren_nr);
    kosten returnkosten(
            int verfahren_nr,
            int mv1,
            int abstand,
			int abstand2,
            double grossvieheinheit,
            int viehID);
    bool save_massnahme(
            string name,
            int mv1massnahme,
            int abstand2massnahme,
			int abstand3massnahme,
            int tierart,
            double grossvieheinheit,
            bool duengung,
            int verfahren_nr);
    bool get_pixel( pixel*** matrix, int bland);
    bool get_pixel( pixel*** matrix, int bland, bool hoch);
    bool** get_vorkommen(
            int artID,
            double reichweite,
            int zeilen,
            int spalten,
            int bundeslandID);
    list< int> getgruenland_for_massnahme_from_database(
            int massnahmeID,
            bool weide);
    massnahme** returnmassnahmen( int& anzahl);
    vector< gruenland*> returngruenland( int& anzahl);
    void returndistinctgruenland(
            gruenland& gruen,
            string name,
            string savetime,
            bool mager);
    bool save_ergebnis(
            int pixelID,
            int massnahmeID,
            int konfiguration,
            double kosten,
            vector< ergebnis::qart> artqualitaet);
    bool save_ergebnis(
            int pixelID,
            int massnahmeID,
            int konfiguration,
            double kosten,
            vector< modell::artenqualitaet> artqualitaet);
    bool save_konfiguration(
            int konfiguration,
            int massnahme,
            double zahlung,
            double flaeche,
            CString konfigname,
            int bundeslandID);
    bool delete_ergebnis( int konfiguration);
    double get_trittmortalitaet( int viehID, double typ);
    void get_ertrags_besatz_grenzen(
            int& gzniedrigmax,
            int& gzmittelmax,
            int& gzhochmax,
            int& gzsehrhochmax,
            double& besatzniedrigmax,
            double& besatzmittelmax,
            double& besatzhochmax,
            double& besatzsehrhochmax);
    wuchshoehe get_wuchshoehe( int leistungsID);
    void save_mas_gr( int massID, int gruenlandID);
    int save_gruenland( gruenland& gruen);
    void get_massnahmen_for_gruenland(
            vector< massnahme>& mass,
            int gruenlandID);
    void getgruenland( vector< gruenland>& gr, int lebensraumID);

    void get_matrix_referenz( int& zeilen, int& spalten, int bundeslandID);
    bool get_matrix_referenz( 
            int& zeilen, 
            int& spalten, 
            double& x_untenlinks,
            double& y_untenlinks,
            int bundeslandID);
    massnahme returnmassnahme(
            CString name,
            int mv1massnahme,
            int abstand2massnahme,
			int abstand3massnahme,
            bool duengung,
            double grossvieheinheit,
            int tierart);
    void returnmassnahmen_gruppe(
            vector< massnahme>& massnahmengruppe,
            CString gruppe);
    void returnmassnahmen_gruppe( vector< massnahme>& massnahmengruppe);
    vector< string> returnmassnahmenname();
    vector< int> returnmassnahmenstart( CString name);
    vector< int> returnmassnahmenabstand( CString name, int mv1massnahme);
	vector< int> returnmassnahmenabstand2( CString name, int mv1massnahme,int abstand2massnahme);
    vector< double> returnmassnahmenGV(
            CString name,
            int mv1massnahme,
            int abstand2massnahme,
			int abstand3massnahme);
    vector< string> returnmassnahmentierart(
            CString name,
            int mv1massnahme,
            int abstand2massnahme,
			int abstand3massnahme);
    vector< bool> returnmassnahmenduengung(
            CString name,
            int mv1massnahme,
            int abstand2massnahme,
			int abstand3massnahme);
    bool save_zwischenvis(
            int massnahmeID,
            CString massnahmen_art,
            int artID,
            CString art_name,
            double qualitaet,
            int pixelID,
            int pixel_i,
            int pixel_j,
            double gewinn,
            double zahlung,
            int gruenlandID,
            int bundesland);
    bool save_zwischenvis(
            int massnahmeID,
            CString massnahmen_art,
            int artID,
            CString art_name,
            double qualitaet,
            int pixelID,
            int pixel_i,
            int pixel_j,
            double gewinn,
            double zahlung,
            int bundesland);
    bool save_ergebnis_zwischenvis(
            int pixelID,
            int massnahmeID,
            double zahlung,
            double gewinn,
            double qualitaet,
            string artenqual);
    bool delete_ergebnis_zwischenvis( void);
    bool delete_zwischenvis( void);
    bool delete_graphic( void);
    vector< CString> returnbundeslandname( void);
    int returnbundeslandID( CString name);
    void save_ergebnis_graphic(
            int massnahmenID,
            int artID,
            CString m_name,
            CString art_name,
            double qual_min,
            double qual_max,
            double qual_mittel,
            double kosten_min,
            double kosten_max,
            double kosten_mittel);
    vector< CString> getpixelfields( void);
    string updatePixel( 
            int bundeslandID, 
            double xCoord, 
            double yCoord, 
            CString attname, 
            CString attToken);
    string insertPixel(
            int bundeslandID,
            CString bundeslandname,
            double xCoord,
            double yCoord,
            int matrix_i,
            int matrix_j);
	
	void get_verwertbarkeit(vector<kosten::verwertbarkeit>& verwert);

 bool get_bundesland(int bundeslandID, int& start, int& niedrig, int& mittel);

	bool save_optimierungsfortgang(int optID,
								   int it,
								   CString aup,
								   double f,
								   double f_best,
								   double schranke,
								   double Temp,
								   double Wkt);
	bool delete_optimierungsfortgang(void);

	bool save_heurtest(	vector<CString> name,
						int anzWiederholungen,
						vector<int> anzBeste,
						vector<double> AnteilAnBesterDurch,
						vector<double> AnteilAnBesterVar,
						vector<int> anzBudOk,
						vector<double> durchBudAuss,
						vector<int> anzOhneLoes,
						vector<double> durchRang);
	bool save_itzahltest(vector<vector<vector<double>>> Statistik, vector<int> ItZahlen);
	bool speichereStichproben(vector<CString> namen,
							 vector<CString> mass,
							 vector<vector<double>> Stichprobe);





private:
    string DBHOST, USER, PASSWORD, DATABASE;
};
