package main

import (
	"database/sql"
	"log"

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

var (
	dbConnection = "wdmdbuser:wdmdbpass@tcp(ubodroid-2:3300)/wdmdb"
	dbType       = "mysql"
)

// Tool Funktionen
func CreateTyp(typ Typ) (resTyp Typ, 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 = ", typ.Bezeichnung)
	defer conn.Close()
	res, err := conn.Exec("INSERT INTO typ VALUES(?,?)", typ.Id, typ.Bezeichnung)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	typ.Id = uint(lastId)
	resTyp = typ
	return resTyp, err
}

func DeleteTyp(typId 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 (DELETE)")
	defer conn.Close()
	_, err = conn.Exec("DELETE FROM typ WHERE id = ?", typId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowTyp() (typArray []Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM typ")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var typ Typ
	for results.Next() {
		err = results.Scan(&typ.Id, &typ.Bezeichnung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		typArray = append(typArray, typ)
	}
	return typArray, err
}

func GetTyp(id uint) (typ Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM typ WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&typ.Id, &typ.Bezeichnung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}
	return typ, err
}

func UpdateTyp(typ Typ) (resTyp Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (UPDATE)")
	log.Println("Name = ", typ.Bezeichnung)
	defer conn.Close()
	_, err = conn.Exec("UPDATE typ SET bezeichnung=? WHERE id=?", typ.Bezeichnung, typ.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	resTyp = typ
	return resTyp, err
}

// Photo Funktionen
func CreatePhoto(pho Photos) (resPhoto Photos, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (Photo CREATE)")
	log.Println("Name = ", pho.Pfad)
	defer conn.Close()
	res, err := conn.Exec("INSERT INTO photo VALUES(?,?,?,?)", pho.Id, pho.Pfad, pho.ItembId, pho.ItemextId)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	pho.Id = uint64(lastId)
	resPhoto = pho
	return resPhoto, err
}

func DeletePhoto(phoId 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 (Photo DELETE)")
	defer conn.Close()
	_, err = conn.Exec("DELETE FROM photo WHERE id = ?", phoId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowPhoto() (phoArray []Photos, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (Photo SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM photos")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var pho Photos
	for results.Next() {
		err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		phoArray = append(phoArray, pho)
	}
	return phoArray, err
}

func GetPhotoForItb(itbid uint64) (phoArray []Photos, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (Photo Itb SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM photos where itembid=?", itbid)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var pho Photos
	for results.Next() {
		err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		phoArray = append(phoArray, pho)
	}
	return phoArray, err
}

func GetPhoto(id uint64) (pho Photos, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (Photo SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM photos WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}
	return pho, err
}

func UpdatePhoto(pho Photos) (resPho Photos, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (Photo UPDATE)")
	log.Println("Name = ", pho.Pfad)
	defer conn.Close()
	_, err = conn.Exec("UPDATE photos SET pfad=?, itembid=?, itemextid=? WHERE id=?", pho.Pfad, pho.ItembId, pho.ItemextId, pho.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	resPho = pho
	return resPho, err
}

// Measure Funktionen
func CreateMeasure(mea Measure) (resMea Measure, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (Measure INSERT)")
	log.Println("Name = ", mea.Kurz)
	defer conn.Close()
	res, err := conn.Exec("INSERT INTO measure VALUES(?,?,?,?,?,?,?,?,?,?)", mea.Id, mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	mea.Id = uint64(lastId)
	resMea = mea
	return resMea, err
}

func DeleteMeasure(meaId 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 (Measure DELETE)")
	defer conn.Close()
	_, err = conn.Exec("DELETE FROM measure WHERE id = ?", meaId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowMeasure() (meaArray []Measure, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (Measure SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM measure")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var mea Measure
	for results.Next() {
		err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		meaArray = append(meaArray, mea)
	}
	return meaArray, err
}

func GetMeasure(id uint64) (mea Measure, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (Measure SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM mea WHERE id=?", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}
	return mea, err
}

func UpdateMeasure(mea Measure) (resMea Measure, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (Measure UPDATE)")
	log.Println("Name = ", mea.Kurz)
	defer conn.Close()
	_, err = conn.Exec("UPDATE measure SET brust=?, laenget=?, schulterbreite=?, taillenumfangt=? hueftumfang=?, innennaht=?, laengeb=?, taillenumfangb=?, kurz=? WHERE id=?",
		mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz, mea.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	resMea = mea
	return resMea, err
}

// ItemB Funktionen
func CreateItemB(itemB Itemb) (resItemb Itemb, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (ItemB Create)")
	log.Println("Name = ", itemB.Bezeichnung)
	defer conn.Close()
	res, err := conn.Exec("INSERT INTO itemb VALUES(?,?,?,?,?,?,?,?,?)", itemB.Id, itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.Type.Id, itemB.Material, itemB.Abmessungen.Id, itemB.Frontview.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	itemB.Id = uint64(lastId)
	resItemb = itemB
	return resItemb, err
}

func DeleteItemB(itemBId 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 (ItemB DELETE)")
	defer conn.Close()
	_, err = conn.Exec("DELETE FROM itemb WHERE id = ?", itemBId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowItemB() (itemBArray []Itemb, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (ItemB SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT a.*, b.pfad FROM itemb a, photos b WHERE a.frontviewid=b.id")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var itemB Itemb
	for results.Next() {
		err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.Type.Id, &itemB.Material, &itemB.Abmessungen.Id, &itemB.Frontview.Id, &itemB.Frontview.Pfad)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		itemBArray = append(itemBArray, itemB)
	}
	return itemBArray, err
}

func GetItemB(id uint64) (itemB Itemb, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (ItemB SHOW)")
	defer conn.Close()
	var dbItemb DbIb
	results, err := conn.Query("SELECT a.id, a.bezeichnung, a.kurzbeschreibung, a.groesse, a.farbe, a.material, b.id, b.brust, b.laenget, b.schulterbreite, b.taillenumfangt, b.hueftumfang, b.laengeb, b.taillenumfangb, b.kurz, c.id, c.bezeichnung, d.id, d.pfad, d.itembid, d.itemextid FROM itemb a, measure b, typ c, photos d WHERE a.id=? AND b.id=a.abmessungenid AND a.typid=c.id AND a.frontviewid=d.id", id)
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	for results.Next() {
		/*	err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.Material,
			&itemB.Abmessungen.Id, &itemB.Abmessungen.Brust, &itemB.Abmessungen.LaengeT, &itemB.Abmessungen.Schulterbreite, &itemB.Abmessungen.TaillenumfangT, &itemB.Abmessungen.Hueftumfang,
			&itemB.Abmessungen.LaengeB, &itemB.Abmessungen.TaillenumfangB, &itemB.Abmessungen.Kurz, &itemB.Type.Id, &itemB.Type.Bezeichnung)
		*/
		err = results.Scan(&itemB.Id, &dbItemb.Bezeichnung, &dbItemb.Kurzbeschreibung, &dbItemb.Groesse, &dbItemb.Farbe, &dbItemb.Material,
			&itemB.Abmessungen.Id, &dbItemb.Abmessungen.Brust, &dbItemb.Abmessungen.LaengeT, &dbItemb.Abmessungen.Schulterbreite, &dbItemb.Abmessungen.TaillenumfangT, &dbItemb.Abmessungen.Hueftumfang,
			&dbItemb.Abmessungen.LaengeB, &dbItemb.Abmessungen.TaillenumfangB, &dbItemb.Abmessungen.Kurz, &itemB.Type.Id, &itemB.Type.Bezeichnung, &itemB.Frontview.Id, &itemB.Frontview.Pfad, &dbItemb.Frontview.ItembId, &dbItemb.Frontview.ItemextId)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		if dbItemb.Bezeichnung.Valid {
			itemB.Bezeichnung = dbItemb.Bezeichnung.String
		} else {
			itemB.Bezeichnung = ""
		}
		if dbItemb.Kurzbeschreibung.Valid {
			itemB.Kurzbeschreibung = dbItemb.Kurzbeschreibung.String
		} else {
			itemB.Kurzbeschreibung = ""
		}
		if dbItemb.Groesse.Valid {
			itemB.Groesse = dbItemb.Groesse.String
		} else {
			itemB.Groesse = ""
		}
		if dbItemb.Farbe.Valid {
			itemB.Farbe = dbItemb.Farbe.String
		} else {
			itemB.Farbe = ""
		}
		if dbItemb.Material.Valid {
			itemB.Material = dbItemb.Material.String
		} else {
			itemB.Material = ""
		}
		if dbItemb.Abmessungen.Brust.Valid {
			itemB.Abmessungen.Brust = dbItemb.Abmessungen.Brust.Float64
		} else {
			itemB.Abmessungen.Brust = 0
		}
		if dbItemb.Abmessungen.LaengeT.Valid {
			itemB.Abmessungen.LaengeT = dbItemb.Abmessungen.LaengeT.Float64
		} else {
			itemB.Abmessungen.LaengeT = 0
		}
		if dbItemb.Abmessungen.Schulterbreite.Valid {
			itemB.Abmessungen.Schulterbreite = dbItemb.Abmessungen.Schulterbreite.Float64
		} else {
			itemB.Abmessungen.Schulterbreite = 0
		}
		if dbItemb.Abmessungen.TaillenumfangT.Valid {
			itemB.Abmessungen.TaillenumfangT = dbItemb.Abmessungen.TaillenumfangT.Float64
		} else {
			itemB.Abmessungen.TaillenumfangT = 0
		}
		if dbItemb.Abmessungen.Hueftumfang.Valid {
			itemB.Abmessungen.Hueftumfang = dbItemb.Abmessungen.Hueftumfang.Float64
		} else {
			itemB.Abmessungen.Hueftumfang = 0
		}
		if dbItemb.Abmessungen.LaengeB.Valid {
			itemB.Abmessungen.LaengeB = dbItemb.Abmessungen.LaengeB.Float64
		} else {
			itemB.Abmessungen.LaengeB = 0
		}
		if dbItemb.Abmessungen.TaillenumfangB.Valid {
			itemB.Abmessungen.TaillenumfangB = dbItemb.Abmessungen.TaillenumfangB.Float64
		} else {
			itemB.Abmessungen.TaillenumfangB = 0
		}
		if dbItemb.Abmessungen.Kurz.Valid {
			itemB.Abmessungen.Kurz = dbItemb.Abmessungen.Kurz.String
		} else {
			itemB.Abmessungen.Kurz = ""
		}
		if dbItemb.Frontview.ItembId.Valid {
			itemB.Frontview.ItembId = uint64(dbItemb.Frontview.ItembId.Int64)
		} else {
			itemB.Frontview.ItembId = 0
		}
		if dbItemb.Frontview.ItemextId.Valid {
			itemB.Frontview.ItemextId = uint64(dbItemb.Frontview.ItemextId.Int64)
		} else {
			itemB.Frontview.ItemextId = 0
		}

	}
	return itemB, err
}

func UpdateItemB(itemB Itemb) (resItemb Itemb, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt (ItemB UPDATE)")
	log.Println("Name = ", itemB.Bezeichnung)
	defer conn.Close()
	_, err = conn.Exec("UPDATE itemb SET bezeichnung=?, kurzbeschreibung=?, groesse=?, farbe=?, typid=?, material=?, abmessungenid=?, frontviewid=? WHERE id=?", itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.Type.Id, itemB.Material, itemB.Abmessungen.Id, itemB.Frontview.Id, itemB.Id)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	resItemb = itemB
	return resItemb, err
}