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
	SysLoad string
	CpuUsage string
}

var db *sql.DB

var cpuUsage int8
var sysLoad float32
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:
				fmt.Printf("%v\n", t)
				fetchLoadMinutely(t)
				fetchCpuMinutely(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"
	p.SysLoad = fmt.Sprint(sysLoad)
	p.CpuUsage = fmt.Sprint(cpuUsage)
	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
	}

	sysLoad = lavg1
	fmt.Printf("sysLoad: %v/%v/%v\n", lavg1, lavg5, lavg15)
	return
}

var lastCpuTotal, lastCpuTotalIdle uint64 = 0, 0
func fetchCpuMinutely(_t time.Time) {
	file, err := os.Open("/proc/stat")
	if err != nil {
		fmt.Printf("Error fetching CPU usage: %v\n", err)
		return
	}
	defer file.Close()

	var cpuUser, cpuNice, cpuSystem, cpuIdle, cpuIOWait, cpuIRQ, cpuSoftIRQ, cpuSteal uint64
	var cpu string
	ret, err := fmt.Fscanf(file, "%s %d %d %d %d %d %d %d %d", &cpu, &cpuUser, &cpuNice, &cpuSystem, &cpuIdle, &cpuIOWait, &cpuIRQ, &cpuSoftIRQ, &cpuSteal)
	if err != nil || cpu != "cpu" || ret < 9 {
		fmt.Printf("Can't parse /proc/stat: %v\n", err)
		return
	}

	cpuTotal := cpuUser + cpuNice + cpuSystem + cpuIdle + cpuIOWait + cpuIRQ + cpuSoftIRQ + cpuSteal
	cpuTotalIdle := cpuIdle + cpuIOWait
	if lastCpuTotal != 0 && lastCpuTotalIdle != 0 {
		cpuUsage = int8(100-float32((cpuTotalIdle-lastCpuTotalIdle))/float32((cpuTotal-lastCpuTotal))*100)
		fmt.Printf("CPU: %v %%\n", cpuUsage)
	}
	lastCpuTotal = cpuTotal
	lastCpuTotalIdle = cpuTotalIdle
}