package server

import (
	"net/http"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/names"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
	owner := r.PathValue("owner")
	name := strings.TrimSuffix(r.PathValue("repo"), ".git")
	repo, err := s.Store.RepoByPath(r.Context(), owner, name)
	if err != nil {
		http.NotFound(w, r)
		return store.User{}, store.Repo{}, "", false
	}
	p := s.who(r)
	var role access.Role
	if p.OK {
		role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
		if err != nil {
			http.Error(w, "rechten", http.StatusInternalServerError)
			return store.User{}, store.Repo{}, "", false
		}
	}
	readable := role.CanRead() || repo.Visibility == "public"
	if !readable {
		if p.OK {
			http.Error(w, "geen toegang", http.StatusForbidden)
		} else {
			http.NotFound(w, r)
		}
		return store.User{}, store.Repo{}, "", false
	}
	if min != access.RoleReadonly && !role.AtLeast(min) {
		http.Error(w, "geen toegang", http.StatusForbidden)
		return store.User{}, store.Repo{}, "", false
	}
	return p.User, repo, role, true
}

func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
	v := s.view(w, r, title)
	v.Repo = &repo
	v.Role = role
	v.CanWrite = role.CanWriteCode()
	v.CanAdmin = role.CanManageSettings()
	v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
	v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
	v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
	return v
}

func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, repo.FullPath())
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	commits, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 8)
	v.Commits = toCommits(commits)
	entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, "")
	if err == nil {
		v.Entries = toEntries("", entries)
	}
	s.render(w, "repo", v)
}

func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	rel, err := cleanRel(r.PathValue("path"))
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, rel)
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v.TreePath = rel
	v.Entries = toEntries(rel, entries)
	s.render(w, "tree", v)
}

func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	rel, err := cleanRel(r.PathValue("path"))
	if err != nil || rel == "" {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, rel)
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 200_000)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v.BlobPath = rel
	v.Blob = text
	v.Binary = binary
	s.render(w, "blob", v)
}

func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Commits")
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
	v.Commits = toCommits(list)
	s.render(w, "commits", v)
}

func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	sha := r.PathValue("sha")
	if !safeSHA(sha) {
		http.NotFound(w, r)
		return
	}
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, c.Subject)
	row := toCommits([]gitrepo.Commit{c})[0]
	v.Commit = &row
	s.render(w, "commit", v)
}

func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Branches")
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	for _, name := range names {
		v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
	}
	s.render(w, "branches", v)
}

func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Merge requests")
	v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
	for _, name := range names {
		v.Branches = append(v.Branches, BranchRow{Name: name})
	}
	s.render(w, "mrs", v)
}

func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if !role.CanWriteCode() {
		http.Error(w, "geen toegang", http.StatusForbidden)
		return
	}
	source := safeRev(r.FormValue("source"), "")
	target := safeRev(r.FormValue("target"), repo.DefaultBranch)
	if source == "" || source == target {
		s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", "kies twee verschillende branches")
		return
	}
	mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
	if err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", err.Error())
		return
	}
	s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, "merge request !"+strconv.FormatInt(mr.Number, 10)+" geopend: "+mr.Title, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10)))
	s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Merge request geopend", "")
}

func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, mr.Title)
	v.MR = &mr
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
	if err == nil {
		v.Diff = diff
	}
	s.render(w, "mr", v)
}

func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	mr, err := s.mrFromRequest(r, repo.ID)
	if err != nil || mr.Status != "open" {
		http.NotFound(w, r)
		return
	}
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
		http.Error(w, "geen toegang tot de doelbranch", http.StatusForbidden)
		return
	}
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	before, _ := gitrepo.Refs(r.Context(), s.Git, dir)
	work := s.Cfg.StoragePath + "/tmp/merge-" + strconv.FormatInt(mr.ID, 10)
	email := u.Username + "@users.git.timfalken.com"
	msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
	if err := gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", err.Error())
		return
	}
	_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
	after, _ := gitrepo.Refs(r.Context(), s.Git, dir)
	s.AfterPush(repo, u, before, after)
	s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Samengevoegd", "")
}

func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	mr, err := s.mrFromRequest(r, repo.ID)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	if mr.AuthorID != u.ID && !role.CanManageSettings() {
		http.Error(w, "geen toegang", http.StatusForbidden)
		return
	}
	_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
	s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Gesloten", "")
}

func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		return store.MergeRequest{}, err
	}
	return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
}

func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Pipelines")
	v.Pipes, _ = s.Store.ListPipelines(r.Context(), repo.ID)
	s.render(w, "pipelines", v)
}

func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, "Pipeline")
	v.Pipe = &p
	v.Jobs, _ = s.Store.JobsByPipeline(r.Context(), p.ID)
	s.render(w, "pipeline", v)
}

func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	shaOut, err := gitSHA(r, s.Git, dir, ref)
	if err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", "branch niet gevonden")
		return
	}
	s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username)
	s.redirect(w, r, repoURL(repo)+"/-/pipelines", "Pipeline gestart als er een blue-ci-cd.yml is", "")
}

func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Releases")
	v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
	s.render(w, "releases", v)
}

func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	name := strings.TrimSpace(r.FormValue("name"))
	if err := names.ValidRepoName(name); err != nil {
		s.redirect(w, r, "/new", "", err.Error())
		return
	}
	ownerKind := "user"
	ownerID := u.ID
	if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
		g, err := s.Store.GroupByPath(r.Context(), gpath)
		if err != nil {
			s.redirect(w, r, "/new", "", "groep niet gevonden")
			return
		}
		role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
		if err != nil || !role.CanManageSettings() {
			http.Error(w, "geen toegang", http.StatusForbidden)
			return
		}
		ownerKind, ownerID = "group", g.ID
	}
	vis := r.FormValue("visibility")
	if vis != "public" {
		vis = "private"
	}
	repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
	if err != nil {
		s.redirect(w, r, "/new", "", err.Error())
		return
	}
	dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
	if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
		_ = s.Store.DeleteRepo(r.Context(), repo.ID)
		s.redirect(w, r, "/new", "", "git init: "+err.Error())
		return
	}
	s.redirect(w, r, repoURL(repo), "Repository aangemaakt", "")
}

func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	g, err := s.Store.CreateGroup(r.Context(), u.ID, r.FormValue("name"), r.FormValue("path"), r.FormValue("description"))
	if err != nil {
		s.redirect(w, r, "/new", "", err.Error())
		return
	}
	s.redirect(w, r, "/groups/"+g.Path, "Groep aangemaakt", "")
}

func toCommits(in []gitrepo.Commit) []CommitRow {
	var out []CommitRow
	for _, c := range in {
		out = append(out, CommitRow{SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date, Subject: c.Subject, Body: c.Body})
	}
	return out
}

func toEntries(base string, in []gitrepo.Entry) []EntryRow {
	var out []EntryRow
	for _, e := range in {
		p := e.Name
		if base != "" {
			p = base + "/" + e.Name
		}
		out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
	}
	return out
}

func cleanRel(p string) (string, error) {
	p = strings.TrimPrefix(p, "/")
	if p == "" || p == "." {
		return "", nil
	}
	if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
		return "", errBadID
	}
	return p, nil
}

func safeRev(s, fallback string) string {
	if s == "" {
		return fallback
	}
	if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
		return fallback
	}
	return s
}

func safeSHA(s string) bool {
	if len(s) < 7 || len(s) > 64 {
		return false
	}
	for _, c := range s {
		if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
			return false
		}
	}
	return true
}
