package server

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

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

func wantsModal(r *http.Request) bool {
	return r.Header.Get("X-BlueGit") == "modal"
}

func writeModal(w http.ResponseWriter, ok bool, url, problem string, status int) {
	if status == 0 {
		status = http.StatusOK
	}
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(map[string]any{"ok": ok, "url": url, "error": problem})
}

func (s *Server) finishCreate(w http.ResponseWriter, r *http.Request, path, notice string) {
	if wantsModal(r) {
		writeModal(w, true, path, "", http.StatusOK)
		return
	}
	s.redirect(w, r, path, notice, "")
}

func (s *Server) failCreate(w http.ResponseWriter, r *http.Request, problem string) {
	if wantsModal(r) {
		writeModal(w, false, "", problem, http.StatusBadRequest)
		return
	}
	s.redirect(w, r, "/new", "", problem)
}

func (s *Server) csrfValue(w http.ResponseWriter, r *http.Request) bool {
	p := s.who(r)
	if !p.OK || r.FormValue("csrf") == "" || r.FormValue("csrf") != p.Session.CSRF {
		http.Error(w, s.tr(r, "err.badCSRF"), http.StatusBadRequest)
		return false
	}
	return true
}

func (s *Server) saveProfile(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if _, err := s.opSetProfile(r.Context(), u, r.FormValue("name"), r.FormValue("bio")); err != nil {
		s.redirect(w, r, "/settings", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, "/settings", s.tr(r, "flash.profile"), "")
}

func (s *Server) saveLanguage(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	lang, err := s.opSetLanguage(r.Context(), u, r.FormValue("language"))
	if err != nil {
		s.redirect(w, r, "/settings", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, "/settings", i18n.T(lang, "flash.language"), "")
}

func (s *Server) saveGroup(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opUpdateGroup(r.Context(), s.who(r).User, g, r.FormValue("description"), r.FormValue("visibility"), r.FormValue("default_role")); err != nil {
		s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")
}

func (s *Server) toggleStar(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if _, err := s.opToggleStar(r.Context(), u, repo); err != nil {
		if !s.uiOK(w, r, repoURL(repo), err) {
			return
		}
	}
	back := r.FormValue("back")
	if !strings.HasPrefix(back, "/") || strings.HasPrefix(back, "//") || strings.Contains(back, "://") {
		back = repoURL(repo)
	}
	s.redirect(w, r, back, s.tr(r, "flash.star"), "")
}

func (s *Server) repoLogo(w http.ResponseWriter, r *http.Request) {
	// Repo-logo volgt de Releases-regel: wie de releases mag zien, ziet ook
	// het logo (privé repo met publieke releases); verder zoals guard.
	repo, ok := s.logoRepo(w, r)
	if !ok {
		return
	}
	s.serveLogo(w, r, "repo", repo.ID, repo.LogoMIME)
}

func (s *Server) groupLogo(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	s.serveLogo(w, r, "group", g.ID, g.LogoMIME)
}

func (s *Server) uploadRepoLogo(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.readUpload(w, r) {
		return
	}
	if err := s.storeLogo(r, "repo", repo.ID); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.logo"), "")
}

func (s *Server) uploadGroupLogo(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.readUpload(w, r) {
		return
	}
	if err := s.storeLogo(r, "group", g.ID); err != nil {
		s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.logo"), "")
}

func (s *Server) readUpload(w http.ResponseWriter, r *http.Request) bool {
	if err := r.ParseMultipartForm(logo.MaxUpload + 4096); err != nil {
		http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest)
		return false
	}
	return s.csrfValue(w, r)
}

func (s *Server) storeLogo(r *http.Request, kind string, id int64) error {
	f, hdr, err := r.FormFile("logo")
	if err != nil {
		return i18n.E("err.logoRead")
	}
	defer f.Close()
	if hdr.Size > logo.MaxUpload {
		return i18n.E("err.logoBig")
	}
	raw, err := io.ReadAll(io.LimitReader(f, logo.MaxUpload+1))
	if err != nil {
		return i18n.E("err.logoRead")
	}
	data, mime, err := logo.Normalize(raw)
	if err != nil {
		return err
	}
	path, err := s.logoPath(kind, id)
	if err != nil {
		return err
	}
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		return i18n.E("err.logoStore")
	}
	if err := os.WriteFile(path, data, 0o644); err != nil {
		return i18n.E("err.logoStore")
	}
	return s.Store.SetLogoMIME(r.Context(), kind, id, mime)
}

func (s *Server) serveLogo(w http.ResponseWriter, r *http.Request, kind string, id int64, mime string) {
	if mime == "" {
		http.NotFound(w, r)
		return
	}
	path, err := s.logoPath(kind, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	data, err := os.ReadFile(path)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	w.Header().Set("Content-Type", mime)
	w.Header().Set("Cache-Control", "private, max-age=60")
	http.ServeContent(w, r, "", time.Time{}, bytes.NewReader(data))
}

func (s *Server) logoPath(kind string, id int64) (string, error) {
	if s.StateDir == "" {
		return "", i18n.E("err.logoStore")
	}
	return filepath.Join(s.StateDir, "logos", kind+"-"+strconv.FormatInt(id, 10)), nil
}

func (s *Server) logoRepo(w http.ResponseWriter, r *http.Request) (store.Repo, bool) {
	if repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo")); err == nil && repo.Visibility != "public" && !isCrawler(r) {
		if _, role, err := s.webRole(r, repo); err == nil && releaseOnly(repo, role) {
			return repo, true
		}
	}
	_, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	return repo, ok
}

func (s *Server) repoCards(ctx context.Context, uid int64, repos []store.Repo, lang i18n.Lang) []RepoCard {
	if len(repos) == 0 {
		return nil
	}
	ids := make([]int64, len(repos))
	for i, repo := range repos {
		ids[i] = repo.ID
	}
	counts, mine, _ := s.Store.StarInfo(ctx, uid, ids)
	cards := make([]RepoCard, 0, len(repos))
	for _, repo := range repos {
		cards = append(cards, RepoCard{
			Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID],
			URL:  s.absURL("/" + repo.FullPath()),
			When: i18n.FormatDate(lang, repo.CreatedAt), Pushed: pushedLabel(lang, repo),
		})
	}
	return cards
}

func (s *Server) starState(ctx context.Context, uid, repoID int64) (int, bool) {
	counts, mine, err := s.Store.StarInfo(ctx, uid, []int64{repoID})
	if err != nil {
		return 0, false
	}
	return counts[repoID], mine[repoID]
}
