package database

import (
	"database/sql"
	"fmt"
	"log"

	"AUDIAG/rtcusertr/domain"

	//"domain.go"
	_ "github.com/go-sql-driver/mysql"
)

var (
	dbConnection = "rtcusertrdbuser:hurtz3585@tcp(ubodroid-1:3306)/rtcusertrdb"
	dbType       = "mysql"
)

// Tool Funktionen
func CreateTool(tool domain.Tools) (resTool domain.Tools, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", tool.Name)
	defer conn.Close()

	res, err := conn.Exec("INSERT INTO tools VALUES(?,?)", tool.Id, tool.Name)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	tool.Id = uint(lastId)
	resTool = tool

	return resTool, err
}

func DeleteTool(toolId uint) (result, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	_, err = conn.Exec("DELETE FROM tools WHERE id = ?", toolId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowTool() (toolsArray []domain.Tools, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM tools")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}

	var tool domain.Tools
	for results.Next() {
		err = results.Scan(&tool.Id, &tool.Name)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		toolsArray = append(toolsArray, tool)
	}
	return toolsArray, err
}

func GetTool(id uint) (tool domain.Tools, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM tools WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&tool.Id, &tool.Name)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}

	return tool, err
}

func UpdateTool(tool domain.Tools) (resTool domain.Tools, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", tool.Name)
	defer conn.Close()

	_, err = conn.Exec("UPDATE tools SET name=? WHERE id=?", tool.Name, tool.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}

	resTool = tool

	return resTool, err
}

// ZTyp Funktionen
func CreateZTyp(ztyp domain.ZTyp) (resZTyp domain.ZTyp, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", ztyp.Name)
	defer conn.Close()

	res, err := conn.Exec("INSERT INTO ztyp VALUES(?,?,?)", ztyp.Id, ztyp.Name, ztyp.Laufzeit)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	ztyp.Id = uint(lastId)
	resZTyp = ztyp

	return resZTyp, err
}

func DeleteZTyp(ztypId uint) (result, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	_, err = conn.Exec("DELETE FROM ztyp WHERE id = ?", ztypId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowZTyp() (ztypArray []domain.ZTyp, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM ztyp")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}

	var ztyp domain.ZTyp
	for results.Next() {
		err = results.Scan(&ztyp.Id, &ztyp.Name, &ztyp.Laufzeit)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		ztypArray = append(ztypArray, ztyp)
	}
	return ztypArray, err
}

func GetZTyp(id uint) (ztyp domain.ZTyp, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM ztyp WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	defer results.Close()
	for results.Next() {
		err = results.Scan(&ztyp.Id, &ztyp.Name, &ztyp.Laufzeit)
		if err != nil {
			if err == sql.ErrNoRows {
				log.Println("No result found with this ID ", err)
				return ztyp, fmt.Errorf("GetZTyp %d: no such ID", id)
			}
			log.Fatal("Error: ", err)
		}
	}
	err = results.Err()
	return ztyp, err
}

func UpdateZTyp(ztyp domain.ZTyp) (resZTyp domain.ZTyp, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", ztyp.Name)
	defer conn.Close()

	_, err = conn.Exec("UPDATE ztyp SET name=?, laufzeit=? WHERE id=?", ztyp.Name, ztyp.Laufzeit, ztyp.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}

	resZTyp = ztyp

	return resZTyp, err
}

// Ablageort Funktionen
func CreateAblOrt(ablort domain.AblageOrt) (resAblOrt domain.AblageOrt, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", ablort.Name)
	defer conn.Close()

	res, err := conn.Exec("INSERT INTO ablageort VALUES(?,?,?,?)", ablort.Id, ablort.Name, ablort.Url, ablort.Pfad)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	ablort.Id = uint(lastId)
	resAblOrt = ablort

	return resAblOrt, err
}

func DeleteAblOrt(ablortId uint) (result, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	_, err = conn.Exec("DELETE FROM ablageort WHERE id = ?", ablortId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowAblOrt() (ablortArray []domain.AblageOrt, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM ablageort")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}

	var ablort domain.AblageOrt
	for results.Next() {
		err = results.Scan(&ablort.Id, &ablort.Name, &ablort.Url, &ablort.Pfad)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		ablortArray = append(ablortArray, ablort)
	}
	return ablortArray, err
}

func GetAblOrt(id uint) (ablort domain.AblageOrt, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM ablageort WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&ablort.Id, &ablort.Name, &ablort.Url, &ablort.Pfad)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}

	return ablort, err
}

func UpdateAblOrt(ablort domain.AblageOrt) (resAblOrt domain.AblageOrt, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", ablort.Name)
	defer conn.Close()

	_, err = conn.Exec("UPDATE ablageort SET name=?, url=?, pfad=? WHERE id=?", ablort.Name, ablort.Url, ablort.Pfad, ablort.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}

	resAblOrt = ablort

	return resAblOrt, err
}

// Zertifikat Funktionen
func CreateZert(zert domain.Zertifikat) (resZert domain.Zertifikat, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", zert.Name)
	log.Println("Erstellungsdatum = ", zert.ErstellDat)
	log.Println("Typ = ", zert.Typ)
	defer conn.Close()

	res, err := conn.Exec("INSERT INTO zertifikat VALUES(?,?,?,?,?,?,?,?,?)", zert.Id, zert.Name, zert.Typ, zert.ErstellDat, zert.GueltigBis, zert.AblageOrt, zert.ErstelltMit, zert.Email, zert.Bemerkung)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	zert.Id = uint64(lastId)
	resZert = zert

	return resZert, err
}

func DeleteZert(zertId uint64) (result, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	_, err = conn.Exec("DELETE FROM zertifikat WHERE id = ?", zertId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowZert() (zertArray []domain.Zertifikat, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM zertifikat")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}

	var zert domain.Zertifikat
	for results.Next() {
		err = results.Scan(&zert.Id, &zert.Name, &zert.Typ, &zert.ErstellDat, &zert.GueltigBis, &zert.AblageOrt, &zert.ErstelltMit, &zert.Email, &zert.Bemerkung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		zertArray = append(zertArray, zert)
	}
	return zertArray, err
}

func GetZert(id uint64) (zert domain.Zertifikat, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt")
	defer conn.Close()

	results, err := conn.Query("SELECT * FROM zertifikat WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&zert.Id, &zert.Name, &zert.Typ, &zert.ErstellDat, &zert.GueltigBis, &zert.AblageOrt, &zert.ErstelltMit, &zert.Email, &zert.Bemerkung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}

	return zert, err
}

func UpdateZert(zert domain.Zertifikat) (resZert domain.Zertifikat, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", zert.Name)
	defer conn.Close()

	_, err = conn.Exec("UPDATE zertifikat SET name=?, typ=?, erstellungsdatum=?, gueltigbis=?, ablageort=?, erstelltmit=?, email=?, bemerkung=? WHERE id=?", zert.Name, zert.Typ, zert.ErstellDat, zert.GueltigBis, zert.AblageOrt, zert.ErstelltMit, zert.Email, zert.Bemerkung, zert.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}

	resZert = zert

	return resZert, err
}