package main

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

	_ "modernc.org/sqlite"
)

type Config struct {
	Port uint
}

type page struct {
	Title string
}

var db *sql.DB

func main() {
	var err error

	// Load config
	fmt.Println("Loading config.json")
	cfgfile, err := os.Open("config.json")
	if err != nil {
		log.Fatal("Error reading config.json!")
		return
	}
	defer cfgfile.Close()

	decoder := json.NewDecoder(cfgfile)
	Config := Config{}
	err = decoder.Decode(&Config)
	if err != nil {
		log.Fatal("Can't decode config.json!")
		return
	}

	db, err = sql.Open("sqlite", "database.db")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Getting loadAvg minutely from /proc/loadavg")
	tickerLAvgMin := time.NewTicker(time.Minute)
	done := make(chan bool)

	go func() {
		for {
			select {
			case <-done:
				return
			case t := <-tickerLAvgMin.C:
				fetchLoadMinutely(t)
			}
		}
	}()
	
	fmt.Printf("Starting HTTP listener on :%v\n", Config.Port)
	http.Handle("/static/", http.FileServer(http.Dir("./")))
	http.HandleFunc("/", httpRootHandler)
	err = http.ListenAndServe(fmt.Sprintf(":%v", Config.Port), nil)
	if err != nil {
		log.Fatal(err)
	}

	db.Close()

}

func httpRootHandler(w http.ResponseWriter, r *http.Request) {
	t, _ := template.ParseFiles("index.html")
	var p page
	p.Title = "Millics"
	t.Execute(w, p)
}

func initDB() {
	// TODO: init DB
	return
}

func fetchLoadMinutely(t time.Time) {
	file, err := os.Open("/proc/loadavg")
	if err != nil {
		fmt.Printf("Error fetching load: %v\n", err)
		return
	}
	defer file.Close()

	var lavg1, lavg5, lavg15 float32
	ret, err := fmt.Fscanf(file, "%f %f %f", &lavg1, &lavg5, &lavg15)
	if err != nil || ret != 3 {
		fmt.Printf("Can't parse /proc/loadavg: %v\n", err)
		return
	}
	
	fmt.Printf("sysLoad %v: %v/%v/%v\n", t, lavg1, lavg5, lavg15)
	return
}