package database

import (
	"database/sql"
	"fmt"
	"spargcom/senuma/domain"

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

var (
	dbConnection = "gosenuma:hurtz@tcp(10.1.1.6:3300)/senuma"
	dbType       = "mysql"
)

func CreateArtikel(art domain.Artikel) (resArt domain.Artikel, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		fmt.Println("Error while connecting DB: ", err)
	}
	fmt.Println("Verbindung hergestellt")
	fmt.Println("Bezeichnung = ", art.Bezeichnung)
	defer conn.Close()

	res, err := conn.Exec("INSERT INTO artikel VALUES(?,?,?)", art.Id, art.Bezeichnung, art.ArtNrExt)
	if err != nil {
		fmt.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	art.Id = uint64(lastId)
	resArt = art

	return resArt, err
}

/*func CreateUser(us domain.User) (resUs domain.User, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		fmt.Println("Error while connecting DB: ", err)
	}
	fmt.Println("Verbindung hergestellt")
	defer conn.Close()
	stmt, err := conn.Prepare("INSERT INTO `user` (`id`, `username`, `full_name`, `email`, `group_id`, `is_active`, `is_admin`, `password`) VALUES(?,?,?,?,?,?,?,?)")
	res, err := stmt.Exec(us.Id, us.Username, us.FullName, us.Email, us.GroupId, us.IsActive, us.IsAdmin, us.Password)
	if err != nil {
		fmt.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	us.Id = uint(lastId)
	resUs = us

	return resUs, err
}

func CreateGroup(grp domain.Group) (resGrp domain.Group, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		fmt.Println("Error while connecting DB: ", err)
	}
	fmt.Println("Verbindung hergestellt")
	defer conn.Close()
	stmt, err := conn.Prepare("INSERT INTO `group` (`id`, `name`, `booked_package`, `billing_address`, `auth_token`, `is_active`, `billing_user`) VALUES(?,?,?,?,?,?,?)")
	res, err := stmt.Exec(grp.Id, grp.Name, grp.BookedPackage, grp.BillingAddress, grp.AuthToken, grp.IsActive, grp.BillingUser)
	if err != nil {
		fmt.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	grp.Id = uint(lastId)
	resGrp = grp

	return resGrp, err
}

func CreateAccount(us domain.User) (resAcc domain.Account, err error) {

	var acc domain.Account
	fmt.Println("User ID:", us.Id)
	fmt.Println("Group ID:", us.GroupId)
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		fmt.Println("Error while connecting DB: ", err)
	}
	fmt.Println("Verbindung hergestellt")
	defer conn.Close()
	stmt, err := conn.Prepare("INSERT INTO `account` (`id`, `group_id`, `created`, `is_active`) VALUES(?,?,?,?)")

	res, err := stmt.Exec(acc.Id, us.GroupId, time.Now(), acc.IsActive)
	if err != nil {
		fmt.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	acc.Id = uint(lastId)
	resAcc = acc
	fmt.Println("Created")
	return resAcc, err

}

func CreateTunnel(tun domain.Tunnel) (resTun domain.Tunnel, err error) {
	fmt.Println("Adding tunnel to database...")
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		fmt.Println("Error while connecting DB: ", err)

	}
	fmt.Println("Verbindung hergestellt")
	defer conn.Close()
	stmt, err := conn.Prepare("INSERT INTO `tunnels` (`id`, `name`, `port`, `is_active`, `created`, `routed_name`, `routed_port`, `account_id`) VALUES(?,?,?,?,?,?,?,?)")

	res, err := stmt.Exec(tun.Id, tun.Name, tun.Port, tun.IsActive, time.Now(), tun.RoutedName, tun.RoutedPort, tun.AccountId)
	if err != nil {
		fmt.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	tun.Id = uint64(lastId)
	resTun = tun
	fmt.Println("Created")
	return resTun, err
}*/