package api

import (
	"net/http"

	"browser.local/platform/domain"
	"browser.local/platform/dto"
)

// serverRuntimeBinding godoc
// @Summary Review or update a server runtime binding
// @Description GET returns redacted logical readiness metadata. PUT changes the selected declared profile and logical refs for an authorized owner or platform administrator.
// @Tags server-instances
// @Accept json
// @Produce json
// @Param id path string true "Server instance ID"
// @Param body body dto.RuntimeBindingUpdateRequest false "Runtime binding update"
// @Success 200 {object} dto.RuntimeBindingResponse
// @Failure 400 {object} dto.ErrorResponse
// @Failure 401 {object} dto.ErrorResponse
// @Failure 403 {object} dto.ErrorResponse
// @Failure 404 {object} dto.ErrorResponse
// @Failure 405 {object} dto.ErrorResponse
// @Router /api/v1/server-instances/{id}/runtime-binding [get]
// @Router /api/v1/server-instances/{id}/runtime-binding [put]
func (h *coreHandlers) serverRuntimeBinding(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		binding, err := h.core.GetServerRuntimeBindingForSession(bearerToken(r), r.PathValue("id"))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusOK, dto.RuntimeBindingFromDomain(binding))
	case http.MethodPut:
		request, err := decodeJSON[dto.RuntimeBindingUpdateRequest](r)
		if err != nil {
			writeDecodeError(w, err)
			return
		}
		binding, err := h.core.UpdateServerRuntimeBindingForSession(bearerToken(r), r.PathValue("id"), request.ToDomain())
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusOK, dto.RuntimeBindingFromDomain(binding))
	default:
		writeMethodNotAllowed(w, "GET, PUT")
	}
}

func (h *coreHandlers) serverRuntimeActions(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	actions, err := h.core.GetServerRuntimeActionsForSession(bearerToken(r), r.PathValue("id"))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.ServerRuntimeActionsFromDomain(actions))
}

func (h *coreHandlers) serverRunGenerate(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.RunDistributionGenerateRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	distribution, err := h.core.GenerateRunDistributionForSession(bearerToken(r), request.ToDomain(r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusCreated, dto.RunDistributionFromDomain(distribution))
}

func (h *coreHandlers) serverRunDownload(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	reference, err := h.core.OpenLatestRunDistributionDownloadForSession(bearerToken(r), r.PathValue("id"))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.ArtifactDownloadReferenceFromDomain(reference))
}

func (h *coreHandlers) serverRunKeyReset(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	key, err := h.core.ResetComponentKeyForSession(bearerToken(r), domain.ComponentKeyResetRequest{ServerInstanceID: r.PathValue("id"), ComponentKind: domain.DistributionComponentRun})
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.ComponentKeyFromDomain(key))
}

func (h *coreHandlers) serverRunUpdate(w http.ResponseWriter, r *http.Request) {
	if r.Method == http.MethodGet {
		jobs, err := h.core.ListRunUpdateJobsForSession(bearerToken(r), r.PathValue("id"))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusOK, dto.RunUpdateJobListFromDomain(jobs))
		return
	}
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, "GET, POST")
		return
	}
	request, err := decodeJSON[dto.RunUpdateRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	job, err := h.core.PushRunUpdateForSession(bearerToken(r), request.ToDomain(r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusAccepted, dto.RunUpdateJobFromDomain(job))
}

// serverDependencies godoc
// @Summary List declared dependency probes, reviewable install plans, and safe status
// @Description Returns only target, digest, typed step, and bounded dependency evidence for an authorized server user.
// @Tags server-instances
// @Produce json
// @Success 200 {object} dto.DependencyCatalogResponse
// @Failure 401 {object} dto.ErrorResponse
// @Failure 403 {object} dto.ErrorResponse
// @Router /api/v1/server-instances/{id}/dependencies [get]
func (h *coreHandlers) serverDependencies(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	catalog, err := h.core.GetDependencyCatalogForSession(bearerToken(r), r.PathValue("id"))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.DependencyCatalogFromDomain(catalog))
}

func (h *coreHandlers) serverClientManagerGenerate(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.ClientManagerBuildRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	distribution, err := h.core.GenerateClientManagerDistributionForSession(bearerToken(r), request.ToDomain(r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusCreated, dto.ClientManagerDistributionFromDomain(distribution))
}

func (h *coreHandlers) serverClientManagerDownload(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.ClientManagerDownloadRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	reference, err := h.core.OpenLatestClientManagerDistributionDownloadForSession(bearerToken(r), r.PathValue("id"), request.ProfileKey)
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.ArtifactDownloadReferenceFromDomain(reference))
}

func (h *coreHandlers) serverClientManagerKeyReset(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.ComponentKeyResetRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	reset := request.ToDomain(r.PathValue("id"))
	reset.ComponentKind = domain.DistributionComponentClientManager
	key, err := h.core.ResetComponentKeyForSession(bearerToken(r), reset)
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.ComponentKeyFromDomain(key))
}

func (h *coreHandlers) serverDependenciesCheck(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.DependencyJobRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	job, err := h.core.QueueDependencyJobForSession(bearerToken(r), request.ToDomain(r.PathValue("id"), false))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusAccepted, dto.JobFromDomain(job))
}

func (h *coreHandlers) serverDependenciesInstall(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.DependencyJobRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	job, err := h.core.QueueDependencyJobForSession(bearerToken(r), request.ToDomain(r.PathValue("id"), true))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusAccepted, dto.JobFromDomain(job))
}

func (h *coreHandlers) serverLiveLogs(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	instance, err := h.core.GetServerInstanceForSession(bearerToken(r), r.PathValue("id"))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	streams, err := h.core.ListLogStreams(domain.LogStreamFilter{ServerInstanceID: instance.ID})
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.LogStreamListFromDomain(streams))
}

func (h *coreHandlers) serverLogsBackfill(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	request, err := decodeJSON[dto.LogBackfillRequest](r)
	if err != nil {
		writeDecodeError(w, err)
		return
	}
	job, err := h.core.QueueLogBackfillForSession(bearerToken(r), request.ToDomain(r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusAccepted, dto.JobFromDomain(job))
}