package server

import ( "errors" "fmt" "log" "net/http" "path" "strings"

"gitweb/internal/githttp"
"gitweb/internal/gitrepo"

)

// gitKind identifies which git smart-HTTP endpoint a request hit. type gitKind int

const ( gitInfoRefs gitKind = iota gitUploadPack gitReceivePack )

// gitReq describes a matched git smart-HTTP request. type gitReq struct { kind gitKind service githttp.Service // the effective service (upload-pack or receive-pack) urlPath string // URL path with the git suffix stripped, e.g. "/u@d.com/x.git" }

// gitEndpoint recognizes the three git smart-HTTP endpoints by method and path // suffix. It returns ok=false for ordinary browse requests. func gitEndpoint(r *http.Request) (gitReq, bool) { p := r.URL.Path switch { case r.Method == http.MethodGet && strings.HasSuffix(p, "/info/refs"): svc := r.URL.Query().Get("service") switch githttp.Service(svc) { case githttp.UploadPack, githttp.ReceivePack: return gitReq{gitInfoRefs, githttp.Service(svc), strings.TrimSuffix(p, "/info/refs")}, true } // info/refs without a smart service param: fall through to browse (this // also lets someone view a repo's literal info/refs file). return gitReq{}, false case r.Method == http.MethodPost && strings.HasSuffix(p, "/git-upload-pack"): return gitReq{gitUploadPack, githttp.UploadPack, strings.TrimSuffix(p, "/git-upload-pack")}, true case r.Method == http.MethodPost && strings.HasSuffix(p, "/git-receive-pack"): return gitReq{gitReceivePack, githttp.ReceivePack, strings.TrimSuffix(p, "/git-receive-pack")}, true } return gitReq{}, false }

// handleGitHTTP serves a git smart-HTTP request: authenticate, resolve the repo, // authorize (read for clone/fetch, write for push), then run the protocol. func (s *Server) handleGitHTTP(w http.ResponseWriter, r *http.Request, ep gitReq) { user, clean, ok := parseUpspinPath(ep.urlPath) if !ok { s.notFound(w) return }

authUser, ok := s.authenticate(w, r)
if !ok {
	return // 401 already written
}

repoPath, rest, isRepo, err := gitrepo.Locate(s.store, user, clean)
if err != nil {
	s.storeErr(w, err)
	return
}
// Endpoints live only at a repo root.
if !isRepo || rest != "" {
	s.denyRead(w, r, authUser)
	return
}

writing := ep.service == githttp.ReceivePack
if writing {
	// Push always requires an authenticated, authorized writer.
	if authUser == "" {
		s.challenge(w)
		return
	}
	can, err := s.authz.CanWrite(authUser, repoPath)
	if err != nil {
		s.serverErr(w, err)
		return
	}
	if !can {
		// The caller is known; distinguish "can't read" (hide it) from
		// "can read but not write" (explicit 403).
		readable, rerr := s.authz.CanRead(authUser, repoPath)
		if rerr != nil {
			s.serverErr(w, rerr)
			return
		}
		if !readable {
			s.notFound(w)
			return
		}
		http.Error(w, "403 forbidden: no write access", http.StatusForbidden)
		return
	}
} else {
	can, err := s.authz.CanRead(authUser, repoPath)
	if err != nil {
		s.serverErr(w, err)
		return
	}
	if !can {
		s.denyRead(w, r, authUser)
		return
	}
}

switch ep.kind {
case gitInfoRefs:
	storer, release, err := s.repos.GetStorer(repoPath)
	if err != nil {
		s.storeErr(w, err)
		return
	}
	defer release()
	if err := githttp.InfoRefs(w, storer, ep.service); err != nil {
		log.Printf("gitweb: info/refs %s: %v", repoPath, err)
	}
case gitUploadPack:
	// upload-pack streams the packfile from the storer for the whole
	// response; the deferred release keeps the repo's on-disk backing
	// alive until ServeUploadPack returns.
	storer, release, err := s.repos.GetStorer(repoPath)
	if err != nil {
		s.storeErr(w, err)
		return
	}
	defer release()
	if err := githttp.ServeUploadPack(w, r, storer); err != nil {
		log.Printf("gitweb: upload-pack %s: %v", repoPath, err)
	}
case gitReceivePack:
	req, err := githttp.DecodeReceivePack(r)
	if errors.Is(err, githttp.ErrProbe) {
		// git checking the endpoint before streaming a large push.
		if err := githttp.WriteReceivePackResult(w, nil); err != nil {
			log.Printf("gitweb: receive-pack probe %s: %v", repoPath, err)
		}
		return
	}
	if err != nil {
		log.Printf("gitweb: receive-pack decode %s: %v", repoPath, err)
		var tooBig *http.MaxBytesError
		if errors.As(err, &tooBig) {
			http.Error(w, fmt.Sprintf("push too large: the limit is %d MiB", tooBig.Limit>>20),
				http.StatusRequestEntityTooLarge)
			return
		}
		http.Error(w, "malformed receive-pack request: "+err.Error(), http.StatusBadRequest)
		return
	}
	rs, err := s.pusher.ReceivePack(r.Context(), repoPath, req)
	if err != nil {
		log.Printf("gitweb: receive-pack %s: %v", repoPath, err)
		if rs == nil {
			s.serverErr(w, err)
			return
		}
		// rs carries per-ref failure detail; report it to the client.
	}
	if err := githttp.WriteReceivePackResult(w, rs); err != nil {
		log.Printf("gitweb: receive-pack result %s: %v", repoPath, err)
	}
}

}

// cleanRest cleans a URL remainder into an upspin path suffix beginning with // "/". path.Clean collapses any ".." so it cannot escape the user's tree. func cleanRest(rest string) string { return path.Clean("/" + rest) }