package main

import (
	"bytes"
	"crypto/hmac"
	"encoding/json"
	"html/template"
	"net/http"
	"os"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

func mountConnect(u *webUI, c *client, relisten func(string) error) {
	h := u.h
	h.ExtraTop = func(r *http.Request) template.HTML { return u.connectHTML(r, c) }
	u.mux.HandleFunc("POST /connect", u.guardWrite(func(w http.ResponseWriter, r *http.Request) {
		_ = r.ParseForm()
		cur := c.snapshot()
		m := machineFrom(cur)
		if v := strings.TrimSpace(r.FormValue("url")); v != "" {
			m.URL = strings.TrimRight(v, "/")
		}
		if v := strings.TrimSpace(r.FormValue("name")); v != "" {
			m.Name = v
		}
		if v := strings.TrimSpace(r.FormValue("docker")); v != "" {
			m.Docker = v
		}
		if v := strings.TrimSpace(r.FormValue("git")); v != "" {
			m.Git = v
		}
		if v := strings.TrimSpace(r.FormValue("network")); v != "" {
			m.Network = v
		}
		if v := strings.TrimSpace(r.FormValue("ui_listen")); v != "" {
			m.UIListen = v
		}
		if v := strings.TrimSpace(r.FormValue("language")); v != "" {
			m.Language = v
		}
		oldListen := cur.UIListen
		if err := c.setMachine(m); err != nil {
			http.Redirect(w, r, "/?err=rui.connect.err.save", http.StatusSeeOther)
			return
		}
		if m.UIListen != "" && m.UIListen != oldListen && m.UIListen != "off" && relisten != nil {
			if err := relisten(m.UIListen); err != nil {
				http.Redirect(w, r, "/?err=rui.connect.err.listen", http.StatusSeeOther)
				return
			}
		}
		http.Redirect(w, r, "/?ok=rui.connect.ok", http.StatusSeeOther)
	}))
	u.mux.HandleFunc("POST /register", u.guardWrite(func(w http.ResponseWriter, r *http.Request) {
		_ = r.ParseForm()
		url := strings.TrimRight(strings.TrimSpace(r.FormValue("url")), "/")
		tok := strings.TrimSpace(r.FormValue("registration_token"))
		name := strings.TrimSpace(r.FormValue("name"))
		if url == "" || tok == "" {
			http.Redirect(w, r, "/?err=rui.connect.err.register", http.StatusSeeOther)
			return
		}
		if err := registerAndSave(c, url, tok, name); err != nil {
			http.Redirect(w, r, "/?err=rui.connect.err.register", http.StatusSeeOther)
			return
		}
		http.Redirect(w, r, "/?ok=rui.connect.registered", http.StatusSeeOther)
	}))
	u.mux.HandleFunc("GET /api/connection", func(w http.ResponseWriter, r *http.Request) {
		if !u.authed(r) {
			http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
			return
		}
		writeConnJSON(w, c.snapshot())
	})
	u.mux.HandleFunc("PUT /api/connection", func(w http.ResponseWriter, r *http.Request) {
		if !u.authed(r) {
			http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
			return
		}
		var in machineSettings
		if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
			http.Error(w, `{"error":"bad json"}`, http.StatusBadRequest)
			return
		}
		// Leeg token = ongewijzigd.
		if strings.TrimSpace(in.Token) == "" {
			in.Token = c.snapshot().Token
		}
		old := c.snapshot().UIListen
		if err := c.setMachine(in); err != nil {
			http.Error(w, `{"error":"save"}`, http.StatusInternalServerError)
			return
		}
		if in.UIListen != "" && in.UIListen != old && in.UIListen != "off" && relisten != nil {
			if err := relisten(in.UIListen); err != nil {
				http.Error(w, `{"error":"listen"}`, http.StatusBadRequest)
				return
			}
		}
		writeConnJSON(w, c.snapshot())
	})
	u.mux.HandleFunc("POST /api/register", func(w http.ResponseWriter, r *http.Request) {
		if !u.authed(r) {
			http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
			return
		}
		var in struct {
			URL   string `json:"url"`
			Token string `json:"token"`
			Name  string `json:"name"`
		}
		if err := json.NewDecoder(r.Body).Decode(&in); err != nil || strings.TrimSpace(in.URL) == "" || strings.TrimSpace(in.Token) == "" {
			http.Error(w, `{"error":"url and token are required"}`, http.StatusBadRequest)
			return
		}
		if err := registerAndSave(c, strings.TrimRight(strings.TrimSpace(in.URL), "/"), strings.TrimSpace(in.Token), strings.TrimSpace(in.Name)); err != nil {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusBadRequest)
			_ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
			return
		}
		writeConnJSON(w, c.snapshot())
	})
}

func writeConnJSON(w http.ResponseWriter, cfg Config) {
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]any{
		"url": cfg.URL, "name": cfg.Name, "docker": cfg.Docker, "git": cfg.Git,
		"network": cfg.Network, "concurrency": cfg.Concurrency, "ui_listen": cfg.UIListen,
		"language": cfg.Language, "work_dir": cfg.WorkDir, "token_set": strings.TrimSpace(cfg.Token) != "",
		"registered": registered(cfg),
	})
}

func (u *webUI) guardWrite(fn http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !u.authed(r) {
			http.Redirect(w, r, "/login", http.StatusSeeOther)
			return
		}
		if !u.csrfOK(r) {
			http.Error(w, "csrf", http.StatusForbidden)
			return
		}
		fn(w, r)
	}
}

func (u *webUI) csrfOK(r *http.Request) bool {
	if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
		return true
	}
	_ = r.ParseForm()
	return hmac.Equal([]byte(r.FormValue("csrf")), []byte(u.mac("csrf")))
}

func (u *webUI) connectHTML(r *http.Request, c *client) template.HTML {
	lang := u.lang(r)
	cfg := c.snapshot()
	csrf := u.mac("csrf")
	var b bytes.Buffer
	_ = connectTmpl.Execute(&b, map[string]any{
		"T":          func(k string, a ...any) string { return i18n.T(lang, k, a...) },
		"CSRF":       csrf,
		"URL":        cfg.URL,
		"Name":       cfg.Name,
		"Docker":     cfg.Docker,
		"Git":        cfg.Git,
		"Network":    cfg.Network,
		"UIListen":   cfg.UIListen,
		"Language":   cfg.Language,
		"WorkDir":    cfg.WorkDir,
		"Registered": registered(cfg),
	})
	return template.HTML(b.String())
}

var connectTmpl = template.Must(template.New("connect").Parse(`
<section class="panel" id="connect">
  <h2>{{call .T "rui.connect.title"}}</h2>
  <p class="muted">{{call .T "rui.connect.lead"}}</p>
  {{if not .Registered}}
  <form method="post" action="/register" class="rui-form">
    <input type="hidden" name="csrf" value="{{.CSRF}}">
    <label><span class="rui-lbl">{{call .T "rui.connect.url"}}</span><input name="url" value="{{.URL}}" placeholder="https://git.example.com" required></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.regToken"}}</span><input name="registration_token" type="password" autocomplete="off" required></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.name"}}</span><input name="name" value="{{.Name}}"></label>
    <button type="submit">{{call .T "rui.connect.register"}}</button>
  </form>
  {{else}}
  <p class="rui-safe ok">✓ {{call .T "rui.connect.linked"}}</p>
  {{end}}
  <form method="post" action="/connect" class="rui-form">
    <input type="hidden" name="csrf" value="{{.CSRF}}">
    <label><span class="rui-lbl">{{call .T "rui.connect.url"}}</span><input name="url" value="{{.URL}}" placeholder="https://git.example.com"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.name"}}</span><input name="name" value="{{.Name}}"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.docker"}}</span><input name="docker" value="{{.Docker}}"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.git"}}</span><input name="git" value="{{.Git}}"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.network"}}</span><input name="network" value="{{.Network}}"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.uiListen"}}</span><input name="ui_listen" value="{{.UIListen}}"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.language"}}</span><input name="language" value="{{.Language}}" placeholder="en"></label>
    <label><span class="rui-lbl">{{call .T "rui.connect.workDir"}}</span><input value="{{.WorkDir}}" readonly></label>
    <p class="muted">{{call .T "rui.connect.workDirWhy"}}</p>
    <button type="submit">{{call .T "action.save"}}</button>
  </form>
</section>
`))

func registerAndSave(c *client, url, token, name string) error {
	cur := c.snapshot()
	id, outName, runnerTok, err := postRegister(url, token, name, version)
	if err != nil {
		return err
	}
	_ = id
	m := machineFrom(cur)
	m.URL, m.Token, m.Name = url, runnerTok, outName
	return c.setMachine(m)
}

func postRegister(baseURL, token, name, ver string) (id int64, outName, runnerTok string, err error) {
	if name == "" {
		name, _ = os.Hostname()
	}
	body, _ := json.Marshal(map[string]string{"token": token, "name": name, "version": ver})
	resp, err := http.Post(strings.TrimRight(baseURL, "/")+"/api/v1/runners/register", "application/json", bytes.NewReader(body))
	if err != nil {
		return 0, "", "", err
	}
	defer resp.Body.Close()
	var out struct {
		ID      int64  `json:"id"`
		Name    string `json:"name"`
		Token   string `json:"token"`
		Message string `json:"message"`
	}
	_ = json.NewDecoder(resp.Body).Decode(&out)
	if resp.StatusCode != http.StatusCreated || out.Token == "" {
		return 0, "", "", fmtRegister(resp.StatusCode, out.Message)
	}
	return out.ID, out.Name, out.Token, nil
}

func fmtRegister(code int, msg string) error {
	if msg == "" {
		msg = http.StatusText(code)
	}
	return &regError{code: code, msg: msg}
}

type regError struct {
	code int
	msg  string
}

func (e *regError) Error() string { return e.msg }
