package main

import (
	"database/sql"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"strings"
	"time"

	_ "modernc.org/sqlite"
)

func readHtml(res http.ResponseWriter, req *http.Request) {
	g := template.CSS("./html/public/mod.css")
	f, err := template.ParseFiles("./html/wsb.html")
	if err != nil {
		log.Println(err)
	}
	err = f.Execute(res, g)
	if err != nil {
		log.Println(err)
	}

}

func simpRequestResp(res http.ResponseWriter, req *http.Request) {
	fmt.Fprint(res, "Hello, M'Lord", 153*4, " I'm here to serveè")
}
func getMsgFromDB(sqldb *sql.DB, id string, lang string) string {
	var lngs []string
	lngs = append(lngs, lang)
	query := generateSQL("msgs",lngs,[2]string{"content", id})
	res := sqldb.QueryRow(query)
	lng := ""
	dt := res.Scan(&lng)
	if dt != nil {
		return ""
	}
	return lng
}
func queryPacks(sqldb *sql.DB, element *elements) []packages{
	pkg_list:= getPkgIdFromDB(sqldb)
	pkgs := make([]packages,0)
	for _,p := range pkg_list{
		query:= generateSQL("packs_all",[]string{"*"}, [2]string{"id",p} )
		res, err := sqldb.Query(query)
		defer res.Close()
		err = res.Err()
		if err != nil {
			log.Panicln(err)
		}
		for res.Next(){
			npkg := packages{}
			err:=res.Scan(&npkg.Id, &npkg.Name, &npkg.Version, &npkg.ExtraCommand, &npkg.Tag, &npkg.Warning)
			if err != nil {
				log.Fatalln(err)
			}
			npkg.Element = element
			pkgs = append(pkgs, npkg)
		}
	}
	return pkgs
}
func queryDatabase(sqldb *sql.DB, queryRow string) []string{
	
	res:= sqldb.QueryRow(queryRow)
	var values []string
	err := res.Scan(&values)
	if err != nil {
		log.Println(err)
	}
	return values
}
func generateSQL(table string, columns []string, arg ...[2]string) string{
	cols:=strings.Join(columns, ",")
	table="SELECT " + cols +" FROM " + table
	if len(arg) > 0{
		table += " WHERE "
		for i, a := range arg{
			table += a[0] + " like '" + a[1] + "'"
			if(i+1 < len(arg)){
				table += " and "
			}
		}
	}
	return table 
}
func getPkgIdFromDB(sqldb *sql.DB) []string {
	query, err := sqldb.Query("SELECT id FROM packs_all")
	defer query.Close()
	err = query.Err()
	if err != nil {
		log.Println(err)
	}
	var pkgs []string
	var tmpstr string
	for query.Next(){
		err = query.Scan(&tmpstr)
		if err != nil {
			log.Println(err)
		}
		pkgs = append(pkgs, tmpstr)
	}
	// query.Scan(&pkgs)
	if err != nil {
		log.Println(err)
	}
	return pkgs
}
func fullSearchDB(sqldb *sql.DB) []packages {
	pkg_list:= getPkgIdFromDB(sqldb)
	var pkgs []packages
	for _,p :=range pkg_list{
		query:= generateSQL("packs_all",[]string{"*"}, [2]string{"id",p} )
		res:= queryDatabase(sqldb, query)
		var pkg packages
		pkg, _=ConvertStringsToPackage(res)
		pkgs = append(pkgs, pkg)
	}
	return pkgs
}
func index(sqldb *sql.DB) http.Handler {
	return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		b := elements{
			Title:          getMsgFromDB(sqldb, "title", "heb"),
			Header:         getMsgFromDB(sqldb, "header", "heb"),
			Help:           getMsgFromDB(sqldb, "help", "heb"),
			Packagename:    getMsgFromDB(sqldb, "packagename", "heb"),
			Packageversion: getMsgFromDB(sqldb, "packageversion", "heb"),
			Allow:          getMsgFromDB(sqldb, "allow", "heb"),
			Warning:        getMsgFromDB(sqldb, "warning", "heb"),
			Explain:        getMsgFromDB(sqldb, "explain", "heb"),
		}
		data := struct {
			ElementsData elements
			PackagesData []packages
		}{
			ElementsData: b,
			PackagesData: queryPacks(sqldb, &b),
		}
		templates, err :=  template.ParseFiles("html/master.html", "html/main.html")
		
		if err != nil {
			log.Println(err)
		}
		err = templates.ExecuteTemplate(res, "master", data)
		if err != nil {
			log.Println(err)
		}
		res.WriteHeader(http.StatusOK)
	})

}
func public() http.Handler {
	return http.StripPrefix("/public/", http.FileServer(http.Dir("./public")))
}
func main() {
	logfilename := "Logs/" + time.Now().Format("2006-01-02--15-04-05") + ".log"
	file, err := os.OpenFile(logfilename, os.O_APPEND|os.O_CREATE, 0777)
	if err != nil {
		os.Exit(12)
	}

	log.SetOutput(file)
	db, err := sql.Open("sqlite", "file:progs.db")
	mux := http.NewServeMux()
	mux.Handle("/public/", public())
	mux.Handle("/", index(db))
	addr := fmt.Sprintf(":%s", "12312")
	server := http.Server{
		Addr:         addr,
		Handler:      mux,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
		IdleTimeout:  15 * time.Second,
	}

	if err := server.ListenAndServe(); err != nil {
		log.Fatalf("main: couldn't start simple server: %v\n", err)
	}
	lang := "heb"

	log.Println(getMsgFromDB(db, "title", lang))
}