package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
	_ "github.com/go-sql-driver/mysql"
	"github.com/spf13/viper"
)

// Global Variables
var db *sql.DB
var dbUser, dbPass, dbHost, dbPort, dbName string

type media struct {
	ID        string `json: "id"`
	YTID      string `json: "yt-id"`
	Url       string `json: "url"`
	Localpath string `json: "localpath"`
	Size      int    `json: "size"`
	Sha256sum string `json: "sha256sum"`
	Length    int    `json: "length"`
	Title     string `json: "title"`
	Author    string `json: "author"`
}

// read db cred
func readdbCred() {
	dbCred := viper.New()
	dbCred.SetConfigName("db-cred")
	dbCred.AddConfigPath(".")
	dbCred.SetConfigType("yaml")
	err := dbCred.ReadInConfig()
	check(err)
	dbUser = dbCred.GetString("dbUser")
	dbPass = dbCred.GetString("dbPass")
	dbHost = dbCred.GetString("dbHost")
	dbPort = dbCred.GetString("dbPort")
	dbName = dbCred.GetString("dbName")
	return
}

// check error
func check(err error) {
	if err != nil {
		panic(err.Error())
	}
}

func opendb() {
	// open db
	sqlopen := fmt.Sprintf(dbUser + ":" + dbPass + "@tcp(" + dbHost + ":" + dbPort + ")/" + dbName)
	var err error
	db, err = sql.Open("mysql", sqlopen)
	check(err)
	fmt.Println("Successfully connected to the database")
}

func dbinit(db *sql.DB) {
	dbinit, err := db.Query("CREATE TABLE IF NOT EXISTS `media` (`id` INT NOT NULL AUTO_INCREMENT, `yt-id` VARCHAR(100), `url` VARCHAR(255), `localpath` TEXT(65535), `size` INT, `sha256sum` VARCHAR(255), `length` INT, `title` VARCHAR(255), `author` VARCHAR(255), PRIMARY KEY (`id`));")
	if err != nil {
		fmt.Println("Error while creating table")
		panic(err.Error())
	}
	defer dbinit.Close()
	fmt.Println("DB-Init successfull")
}

func dbentrycount(db *sql.DB) {
	var count int
	dbcount, err := db.Query("SELECT COUNT(*) FROM testdb.media;")
	if err != nil {
		fmt.Println("Error while counting rows from table")
		panic(err.Error())
	}
	defer dbcount.Close()
	for dbcount.Next() {
		err = dbcount.Scan(&count)
		if err != nil {
			panic(err.Error())
		}
	}
	fmt.Printf("There are %v entries in the database\n", count)
}
func getDB(c *gin.Context) {
	dbquery := fmt.Sprintf("SELECT * FROM testdb.media")
	media, err := getJSON(dbquery)
	check(err)
	c.IndentedJSON(http.StatusOK, media)
}

// func getMedia() []media {
// 	dbquery := fmt.Sprintf("SELECT * FROM testdb.media")
// 	rows, err := db.Query(dbquery)
// 	check(err)
// 	var MediaDB []media
// 	for rows.Next() {
// 		err := rows.Scan(&id, &yt-id, &url, &localpath, &size, &sha256sum, &length, &title, &author)
// 		if err != nil {
// 			if err == sql.ErrNoRows {
// 				log.Println("no rows found in DB")
// 			} else {
// 				panic(err)
// 			}
// 		} else {
// 			MediaDB = append(MediaDB, media{ID: id, YTID: yt - id, Url: url, Localpath: localpath, Size: size, Sha256sum: sha256sum, Length: length, Title: title, Author: author})
// 		}
// 	}
// 	return MediaDB
// }

func getJSON(sqlString string) (string, error) {
	rows, err := db.Query(sqlString)
	if err != nil {
		return "", err
	}
	defer rows.Close()
	columns, err := rows.Columns()
	if err != nil {
		return "", err
	}
	count := len(columns)
	tableData := make([]map[string]interface{}, 0)
	values := make([]interface{}, count)
	valuePtrs := make([]interface{}, count)
	for rows.Next() {
		for i := 0; i < count; i++ {
			valuePtrs[i] = &values[i]
		}
		rows.Scan(valuePtrs...)
		entry := make(map[string]interface{})
		for i, col := range columns {
			var v interface{}
			val := values[i]
			b, ok := val.([]byte)
			if ok {
				v = string(b)
			} else {
				v = val
			}
			entry[col] = v
		}
		tableData = append(tableData, entry)
	}
	jsonData, err := json.Marshal(tableData)
	if err != nil {
		return "", err
	}
	return string(jsonData), nil
}

func main() {
	readdbCred()
	opendb()
	defer db.Close()

	dbinit(db)
	dbentrycount(db)

	router := gin.Default()
	router.GET("/api/db", getDB)
	//router.GET("/api/songs", getMedia)
	router.Run("127.0.0.1:8000")
}