package main

import (
	"bytes"
	"context"
	"debug/buildinfo"
	"encoding/json"
	"fmt"
	"html/template"
	"io"
	"log"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"sync/atomic"
	"time"

	"j3s.sh/gore/internal/assets"
	"j3s.sh/gore/internal/module"

	"golang.org/x/sys/unix"
)

func parseMeminfo() map[string]int64 {
	meminfo, err := os.ReadFile("/proc/meminfo")
	if err != nil {
		return nil
	}
	vals := make(map[string]int64)
	for _, line := range strings.Split(string(meminfo), "\n") {
		if !strings.HasPrefix(line, "MemTotal") &&
			!strings.HasPrefix(line, "MemAvailable") {
			continue
		}
		parts := strings.Split(line, ":")
		if len(parts) < 2 {
			continue
		}
		val, err := strconv.ParseInt(strings.TrimSpace(strings.TrimSuffix(parts[1], " kB")), 0, 64)
		if err != nil {
			continue
		}
		vals[parts[0]] = val * 1024 // KiB to B
	}
	return vals
}

// readFile0 returns the file contents or an empty string if the file could not
// be read. All bytes from any \0 byte onwards are stripped (as found in
// /proc/device-tree/model).
//
// Additionally, whitespace is trimmed.
func readFile0(filename string) string {
	b, _ := os.ReadFile(filename)
	if idx := bytes.IndexByte(b, 0); idx > -1 {
		b = b[:idx]
	}
	return string(bytes.TrimSpace(b))
}

var modelCache atomic.Value // of string

// Model returns a human readable description of the current device model,
// e.g. “Raspberry Pi 4 Model B Rev 1.1” or “PC Engines apu2” or “QEMU”
// or ultimately “unknown model”.
func Model() string {
	if s, ok := modelCache.Load().(string); ok {
		return s
	}
	andCache := func(s string) string {
		modelCache.Store(s)
		return s
	}
	// the supported Raspberry Pis have this file
	if m := readFile0("/proc/device-tree/model"); m != "" {
		return andCache(m)
	}
	// The PC Engines apu2c4 (and other PCs) have this file instead:
	vendor := readFile0("/sys/class/dmi/id/board_vendor")
	name := readFile0("/sys/class/dmi/id/board_name")
	if vendor != "" || name != "" {
		return andCache(vendor + " " + name)
	}
	// QEMU has none of that. But it does say "QEMU" here, so use this as
	// another fallback:
	if v := readFile0("/sys/class/dmi/id/sys_vendor"); v != "" {
		return andCache(v)
	}
	// If we can't find anything else, at least return some non-empty string so
	// fbstatus doesn't render funny with empty parens. Plus this gives people
	// something to grep for to add more model detection.
	return "unknown model"
}

func readModuleInfo(path string) (string, error) {
	bi, err := buildinfo.ReadFile(path)
	if err != nil {
		return "", err
	}
	lines := strings.Split(strings.TrimSpace(bi.String()), "\n")
	shortened := make([]string, len(lines))
	for idx, line := range lines {
		row := strings.Split(line, "\t")
		if len(row) > 3 {
			row = row[:3]
		}
		shortened[idx] = strings.Join(row, "\t")
	}
	return strings.Join(shortened, "\n"), nil
}

func parseUtsname(u unix.Utsname) string {
	if u == (unix.Utsname{}) {
		// Empty utsname, no info to parse.
		return "unknown"
	}

	str := func(b [65]byte) string {
		// Trim all trailing NULL bytes.
		return string(bytes.TrimRight(b[:], "\x00"))
	}

	return fmt.Sprintf("%s %s (%s)",
		str(u.Sysname), str(u.Release), str(u.Machine))
}

func jsonRequested(r *http.Request) bool {
	// When this function was introduced, it incorrectly checked the
	// Content-Type header (which specifies the type of the body, if any), where
	// it should have looked at the Accept header. Hence, we now consider both,
	// at least for some time.
	return strings.Contains(strings.ToLower(r.Header.Get("Accept")), "application/json") ||
		strings.Contains(strings.ToLower(r.Header.Get("Content-type")), "application/json")
}

func eventStreamRequested(r *http.Request) bool {
	return strings.Contains(strings.ToLower(r.Header.Get("Accept")), "text/event-stream")
}

var templates = template.Must(template.New("root").
	Funcs(map[string]interface{}{
		"shortenSHA256": func(hash string) string {
			if len(hash) > 10 {
				return hash[:10]
			}
			return hash
		},
		"restarting": func(t time.Time) bool {
			return time.Since(t).Seconds() < 5
		},

		"last": func(s []string) string {
			if len(s) == 0 {
				return ""
			}
			return s[len(s)-1]
		},

		"megabytes": func(val int64) string {
			return fmt.Sprintf("%.1f MiB", float64(val)/1024/1024)
		},

		"gigabytes": func(val int64) string {
			return fmt.Sprintf("%.1f GiB", float64(val)/1024/1024/1024)
		},

		"baseName": func(path string) string {
			return filepath.Base(path)
		},

		"initRss": func() int64 {
			return rssOfPid(1)
		},

		"rssPercentage": func(meminfo map[string]int64, rss int64) string {
			used := float64(meminfo["MemTotal"] - meminfo["MemAvailable"])
			return fmt.Sprintf("%.f", float64(rss)/used*100)
		},
	}).
	ParseFS(assets.Assets, "*.tmpl"))

func initStatus() {
	model := Model()

	var uname unix.Utsname
	if err := unix.Uname(&uname); err != nil {
		log.Printf("getting uname: %v", err)
	}
	kernel := parseUtsname(uname)

	http.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")

		token := xsrfTokenFromCookies(r.Cookies())
		if token == 0 {
			// Only generate a new XSRF token if the old one is expired, so that
			// loading a different form in the background doesn’t render the
			// current one unusable.
			token = xsrfToken()
		}

		http.SetCookie(w, &http.Cookie{
			Name:     "gore_xsrf",
			Value:    fmt.Sprintf("%d", token),
			Expires:  time.Now().Add(24 * time.Hour),
			HttpOnly: true,
		})

		path := r.FormValue("path")
		svc := findSvc(path)
		if svc == nil {
			http.Error(w, "service not found", http.StatusNotFound)
			return
		}

		if jsonRequested(r) {
			b, err := json.Marshal(svc)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			w.Header().Set("Content-Type", "application/json")
			_, _ = w.Write(b)
			return
		}

		var buf bytes.Buffer
		if err := templates.ExecuteTemplate(&buf, "status.tmpl", struct {
			Service        *service
			BuildTimestamp string
			Hostname       string
			Model          string
			XsrfToken      int32
			Kernel         string
		}{
			Service:        svc,
			BuildTimestamp: buildTimestamp,
			Hostname:       hostname,
			Model:          model,
			XsrfToken:      token,
			Kernel:         kernel,
		}); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		status := "started"
		if svc.Stopped() {
			status = "stopped"
		}
		w.Header().Set("X-Gore-Status", status)
		w.Header().Set("X-Gore-GOARCH", runtime.GOARCH)
		io.Copy(w, &buf)
	})

	http.HandleFunc("/log", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")

		evtStream := eventStreamRequested(r)
		if evtStream {
			w.Header().Set("Content-type", "text/event-stream")
		}

		path := r.FormValue("path")
		svc := findSvc(path)
		if svc == nil {
			http.Error(w, "service not found", http.StatusNotFound)
			return
		}

		streamName := r.FormValue("stream")

		var stream <-chan string
		var closeFunc func()

		switch streamName {
		case "stdout":
			stream, closeFunc = svc.Stdout.Stream()
		case "stderr":
			stream, closeFunc = svc.Stderr.Stream()
		default:
			http.Error(w, "stream not found", http.StatusNotFound)
			return
		}
		defer closeFunc()

		for {
			select {
			case line := <-stream:
				// See https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events for description
				// of server-sent events protocol.
				if evtStream {
					line = fmt.Sprintf("data: %s\n", line)
				}
				if _, err := fmt.Fprintln(w, line); err != nil {
					return
				}
				if f, ok := w.(http.Flusher); ok {
					f.Flush()
				}
			case <-r.Context().Done():
				// Client closed stream. Stop and release all resources immediately.
				return
			}
		}
	})
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	services.Lock()
	defer services.Unlock()
	status := struct {
		Services       []*service
		BuildTimestamp string
		Meminfo        map[string]int64
		Hostname       string
	}{
		Services: services.S,
		Meminfo:  parseMeminfo(),
		Hostname: hostname,
	}

	if jsonRequested(r) {
		b, err := json.Marshal(status)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write(b)
		return
	}

	var buf bytes.Buffer
	if err := templates.ExecuteTemplate(&buf, "overview.tmpl", status); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	io.Copy(w, &buf)
}

func addHandler(w http.ResponseWriter, r *http.Request) {
	formInput := r.FormValue("path")
	if formInput == "" {
		http.Error(w, "Module URL is required (e.g. git.j3s.sh/vore@latest)", http.StatusBadRequest)
		return
	}

	path, version, found := strings.Cut(formInput, "@")
	fmt.Println(path, version)
	if !found {
		version = "latest"
	}

	// First:  we resolve da module using le proxies
	resolved, err := module.Resolve(context.TODO(), path, version)
	if err != nil {
		msg := fmt.Sprintf("Failed to resolve module: %v", err)
		fmt.Fprintf(w, msg)
		log.Println(msg)
		return
	}

	log.Printf(`Adding the following package to gore:
  Go package  : %s
  in Go module: %s`, path, resolved.Module)

	// Next: we install da binary, based on le module data
	buildDir := filepath.Join("builddir", resolved.Module)
	if _, err := os.Stat(buildDir); err != nil {
		log.Printf("Creating builddir for module %s", resolved.Module)
		if err := os.MkdirAll(buildDir, 0755); err != nil {
			log.Printf("Failed to create builddir for module %s: %v", resolved.Module, err)
			return
		}
	}

	//	if _, err := os.Stat(filepath.Join(buildDir, "go.mod")); err == nil {
	//		log.Printf("Adding require line to existing go.mod")
	//	} else {
	//		log.Printf("Creating go.mod based on upstream go.mod")
	//		modf, err := modfile.Parse("go.mod", resolved.GoMod, nil)
	//		if err != nil {
	//			log.Printf("parsing old go.mod: %v", err)
	//			return
	//		}
	//		if err := modf.AddModuleStmt("gore/build/" + resolved.Module); err != nil {
	//			log.Println(err)
	//			return
	//		}
	//
	//		b, err := modf.Format()
	//		if err != nil {
	//			log.Println(err)
	//			return
	//		}

	//		if err := os.WriteFile(filepath.Join(buildDir, "go.mod"), b, 0600); err != nil {
	//			log.Println(err)
	//			return
	//		}
	//	}

	get := exec.Command("go", "install", resolved.Module+"@"+resolved.Version)
	absoluteInstallPath, err := filepath.Abs(filepath.Join(buildDir + "@" + resolved.Version))
	if err != nil {
		fmt.Fprintf(w, "oopsie woopsie, we made a fucky wu- actually, you know what? 500 internal server error. fuck you.")
		log.Println(err)
		return
	}
	get.Env = append(os.Environ(), "CGO_ENABLED=0", "GOBIN="+absoluteInstallPath)
	get.Stdout = os.Stdout
	get.Stderr = os.Stderr
	if err := get.Run(); err != nil {
		fmt.Fprintf(w, "oopsie woopsie, we made a fucky wu- actually, you know what? 500 internal server error. fuck you.")
		log.Println(err)
		return
	}

	// add to service list

	http.Redirect(w, r, "/", http.StatusSeeOther)
}