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 searchDownloads(sqldb *sql.DB, table string, columns ...string) []DownloadElements {
	query := generateSQL(table, columns)
	runquery, err := sqldb.Query(query)
	defer runquery.Close()
	err = runquery.Err()
	if err != nil {
		log.Fatalln(err)
	}
	var elems []DownloadElements
	var e DownloadElements
	for runquery.Next() {
		if len(columns) > 2 {
			err = runquery.Scan(&e.ID, &e.Version, &e.Counter)
		} else {
			err = runquery.Scan(&e.ID, &e.Counter)
		}
		elems = append(elems, e)
	}
	return elems
}
func stats(sqldb *sql.DB, lang string) http.Handler {
	return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		Counter := struct{
			ElementsData elements
			VersionStats []DownloadElements
			TotalStats []DownloadElements
			BodyClass string
			Lang string
		}{
			ElementsData: elements{
				Title:          getMsgFromDB(sqldb, "title", lang),
				Header:         getMsgFromDB(sqldb, "header", lang),
				Help:           getMsgFromDB(sqldb, "help", lang),
				Packagename:    getMsgFromDB(sqldb, "packagename", lang),
				Packageversion: getMsgFromDB(sqldb, "packageversion", lang),
				Allow:          getMsgFromDB(sqldb, "allow", lang),
				Warning:        getMsgFromDB(sqldb, "warning", lang),
				Explain:        getMsgFromDB(sqldb, "explain", lang),
			},
			BodyClass: "m",
			VersionStats: searchDownloads(sqldb, "counterd", "program", "version","download_count"),
			TotalStats: searchDownloads(sqldb, "count_all", "program","download_count"),
			Lang: lang,
		}
		templates, err := template.ParseFiles("html/master.html", "html/statsitics.html")
		if err != nil {
			log.Println(err)
		}
		err = templates.ExecuteTemplate(res, "master", Counter)
		if err != nil {
			log.Println(err)
		}
		res.WriteHeader(http.StatusOK)
	})
}
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 fullSearchPackagesDB(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, lang string) http.Handler {
	return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		pageDataFromDatabase := elements{
			Title:          getMsgFromDB(sqldb, "title", lang),
			Header:         getMsgFromDB(sqldb, "header", lang),
			Help:           getMsgFromDB(sqldb, "help", lang),
			Packagename:    getMsgFromDB(sqldb, "packagename", lang),
			Packageversion: getMsgFromDB(sqldb, "packageversion", lang),
			Allow:          getMsgFromDB(sqldb, "allow", lang),
			Warning:        getMsgFromDB(sqldb, "warning", lang),
			Explain:        getMsgFromDB(sqldb, "explain", lang),
		}
		data := struct {
			ElementsData elements
			PackagesData []packages
			Lang         string
		}{
			ElementsData: pageDataFromDatabase,
			PackagesData: queryPacks(sqldb, &pageDataFromDatabase),
			Lang:         lang,
		}
		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, "heb"))
	mux.Handle("/en", index(db, "eng"))
	mux.Handle("/stats", stats(db,"eng"))
	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))
}