package main

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

	"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() (db *sql.DB) {
	// 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")
	return db
}

func dbinit() {
	dbinit, err := db.Query("CREATE TABLE IF NOT EXISTS `media` (`id` INT NOT NULL AUTO_INCREMENT, `ytid` 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() {
	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 get_api_db(c *gin.Context) {
	dbquery := fmt.Sprintf("SELECT * FROM testdb.media")
	media, err := getJSON(dbquery)
	check(err)
	c.Data(http.StatusOK, "application/json", 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) ([]byte, error) {
	rows, err := db.Query(sqlString)
	check(err)
	defer rows.Close()
	columns, err := rows.Columns()
	if err != nil {
		return []byte("Error while generating json"), 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 []byte("Error while generating json"), err
	}
	return jsonData, nil
}

func get_test_ping(c *gin.Context) {
	c.String(http.StatusOK, "pong")
}
func get_api_add_ytid(c *gin.Context) {
	newSong_ytid := c.Param("ytid")
	newSong_url := "https://www.youtube.com/watch?v=" + newSong_ytid
	_, err := url.ParseRequestURI(newSong_url)
	check(err)
	is_available := ytid_in_db(newSong_ytid)
	c.String(http.StatusOK, is_available)
}

func ytid_in_db(ytid string) string {
	sqlString := fmt.Sprintf("SELECT COUNT(ytid) FROM testdb.media WHERE ytid LIKE \"%v\";", ytid)
	var count int
	err := db.QueryRow(sqlString).Scan(&count)
	check(err)
	if count == 0 {
		return "Song is not available"
	}
	if count == 1 {
		return "Song is available"
	}
	error_return := fmt.Sprintf("Rows returned: %s --> there is an Issue within the database", string(count))
	return error_return
}

func get_api_get_ytid(c *gin.Context) {
	ytid := c.Param("ytid")
	sqlString := fmt.Sprintf("SELECT * FROM testdb.media WHERE ytid LIKE \"%v\";", ytid)
	json, err := getJSON(sqlString)
	check(err)
	c.Data(http.StatusOK, "application/json", json)
}

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

	dbinit()
	dbentrycount()

	router := gin.Default()
	router.GET("/api/db", get_api_db)
	router.GET("/api/add/:ytid", get_api_add_ytid)
	router.GET("/api/get/:ytid", get_api_get_ytid)
	//router.GET("/api/download/:ytid", get_api_download_ytid)
	router.GET("/test/ping", get_test_ping)
	//router.GET("/api/songs", getMedia)
	router.Run("127.0.0.1:8000")
}