package server

import (
	"net/http"
	"strconv"
	"time"

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

func rfcTime(t time.Time) any {
	if t.IsZero() {
		return nil
	}
	return t.UTC().Format(time.RFC3339)
}

func userJSON(u store.User, self bool) map[string]any {
	out := map[string]any{
		"id": u.ID, "username": u.Username, "avatar_url": u.AvatarURL,
	}
	if self {
		out["instance_admin"] = u.InstanceAdmin
		out["language"] = u.Language
	}
	return out
}

func tokenJSON(t store.TokenInfo, plain string) map[string]any {
	out := map[string]any{
		"id": t.ID, "name": t.Name, "prefix": t.Prefix,
		"scopes":       access.StoredScopes(t.Scopes).List(),
		"created_at":   rfcTime(t.CreatedAt),
		"last_used_at": rfcTime(t.LastUsedAt),
		"expires_at":   rfcTime(t.ExpiresAt),
	}
	if plain != "" {
		out["token"] = plain
	}
	return out
}

func (s *Server) apiGetUser(w http.ResponseWriter, r *http.Request) {
	writeJSON(w, http.StatusOK, userJSON(apiUser(r), true))
}

func (s *Server) apiPutUser(w http.ResponseWriter, r *http.Request) {
	var in struct {
		Language string `json:"language"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	lang, err := s.opSetLanguage(r.Context(), apiUser(r), in.Language)
	if !s.apiOK(w, r, err) {
		return
	}
	u := apiUser(r)
	u.Language = string(lang)
	writeJSON(w, http.StatusOK, userJSON(u, true))
}

func (s *Server) apiExport(w http.ResponseWriter, r *http.Request) {
	writeJSON(w, http.StatusOK, s.opExport(r.Context(), apiUser(r)))
}

func (s *Server) apiUserByName(w http.ResponseWriter, r *http.Request) {
	u, err := s.Store.UserByUsername(r.Context(), r.PathValue("username"))
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
		return
	}
	writeJSON(w, http.StatusOK, userJSON(u, false))
}

func (s *Server) apiListTokens(w http.ResponseWriter, r *http.Request) {
	list, err := s.Store.ListTokens(r.Context(), apiUser(r).ID)
	if !s.apiOK(w, r, err) {
		return
	}
	page, per := pageQuery(r)
	rows := make([]map[string]any, 0, len(list))
	for _, t := range list {
		rows = append(rows, tokenJSON(t, ""))
	}
	writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
}

func (s *Server) apiCreateToken(w http.ResponseWriter, r *http.Request) {
	var in struct {
		Name      string   `json:"name"`
		Scopes    []string `json:"scopes"`
		ExpiresAt string   `json:"expires_at"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	var exp time.Time
	if in.ExpiresAt != "" {
		parsed, err := time.Parse(time.RFC3339, in.ExpiresAt)
		if err != nil {
			s.writeAPIErr(w, r, fail(400, i18n.E("err.tokenExpired")))
			return
		}
		exp = parsed
	}
	plain, info, err := s.opIssueToken(r.Context(), apiUser(r), in.Name, in.Scopes, exp)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusCreated, tokenJSON(info, plain))
}

func (s *Server) apiDeleteToken(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
		return
	}
	if !s.apiOK(w, r, s.opRevokeToken(r.Context(), apiUser(r), id)) {
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

func keyJSON(k store.SSHKey) map[string]any {
	return map[string]any{
		"id": k.ID, "name": k.Name, "key": k.PublicKey, "fingerprint": k.Fingerprint,
		"created_at": rfcTime(k.CreatedAt),
	}
}

func (s *Server) apiListKeys(w http.ResponseWriter, r *http.Request) {
	list, err := s.Store.ListSSHKeys(r.Context(), apiUser(r).ID)
	if !s.apiOK(w, r, err) {
		return
	}
	page, per := pageQuery(r)
	rows := make([]map[string]any, 0, len(list))
	for _, k := range list {
		rows = append(rows, keyJSON(k))
	}
	writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
}

func (s *Server) apiAddKey(w http.ResponseWriter, r *http.Request) {
	var in struct {
		Name string `json:"name"`
		Key  string `json:"key"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	if !s.apiOK(w, r, s.opAddSSH(r.Context(), apiUser(r), in.Name, in.Key)) {
		return
	}
	writeJSON(w, http.StatusCreated, map[string]any{"name": in.Name})
}

func (s *Server) apiDeleteKey(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
		return
	}
	if !s.apiOK(w, r, s.opRemoveSSH(r.Context(), apiUser(r), id)) {
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

func (s *Server) apiAdminStorage(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	if r.Method == http.MethodGet {
		writeJSON(w, http.StatusOK, map[string]any{"path": s.StoragePath()})
		return
	}
	var in struct {
		Path string `json:"path"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	info, moved, err := s.opSetStorage(in.Path)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"path": info.Path, "moved": moved, "free": info.Free})
}
