package http

import (
	"context"
	"encoding/json"
	stdhttp "net/http"
	"time"

	"github.com/go-chi/chi/v5"
	"github.com/oklog/ulid/v2"

	"gitea.dcglab.co.uk/steve/restic-manager/internal/api"
	"gitea.dcglab.co.uk/steve/restic-manager/internal/auth"
	"gitea.dcglab.co.uk/steve/restic-manager/internal/store"
)

// runNowRequest is the body of POST /api/hosts/:id/jobs.
type runNowRequest struct {
	Kind api.JobKind `json:"kind"`
	Args []string    `json:"args,omitempty"` // restic CLI args (paths for backup, etc.)
}

type runNowResponse struct {
	JobID  string `json:"job_id"`
	Status string `json:"status"` // "queued"
}

// handleRunNow dispatches a job to the named host. Authenticated;
// rejects if the host isn't connected (caller should retry once
// the agent comes back).
func (s *Server) handleRunNow(w stdhttp.ResponseWriter, r *stdhttp.Request) {
	user, ok := s.requireUser(r)
	if !ok {
		writeJSONError(w, stdhttp.StatusUnauthorized, "unauthorised", "")
		return
	}
	hostID := chi.URLParam(r, "id")
	if hostID == "" {
		writeJSONError(w, stdhttp.StatusBadRequest, "missing_host_id", "")
		return
	}
	var req runNowRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeJSONError(w, stdhttp.StatusBadRequest, "invalid_json", err.Error())
		return
	}

	res, status, code, msg := s.dispatchJob(r.Context(), user, hostID, req.Kind, req.Args)
	if code != "" {
		writeJSONError(w, status, code, msg)
		return
	}
	writeJSON(w, stdhttp.StatusAccepted, res)
}

// dispatchJob is the common path for HTTP-driven job dispatch. It
// validates the kind, checks the host is online, persists the job
// row, and ships command.run over the WS. Returns:
//   - res: the queued-job response (job_id + status)
//   - status: HTTP status to return on failure (or 0 on success)
//   - code, msg: error code/message for the wire (empty on success)
//
// JSON callers wrap with writeJSONError; HTML callers translate to
// flash banner + redirect.
func (s *Server) dispatchJob(ctx context.Context, user *store.User,
	hostID string, kind api.JobKind, args []string,
) (res runNowResponse, status int, code, msg string) {
	payload := api.CommandRunPayload{
		Kind: kind,
		Args: args,
	}
	if kind == api.JobForget {
		if !validForgetArgs(args) {
			return res, stdhttp.StatusBadRequest, "invalid_args",
				"forget accepts no arguments other than --dry-run"
		}
		var ok bool
		var err error
		payload, ok, err = s.buildForgetPayloadForHost(ctx, hostID)
		if err != nil {
			return res, stdhttp.StatusInternalServerError, "internal", ""
		}
		if !ok {
			return res, stdhttp.StatusUnprocessableEntity, "no_retention_policy",
				"host has no source groups with a retention policy"
		}
		payload.Args = args
	}
	return s.dispatchJobWithPayload(ctx, user, hostID, kind, nil, payload)
}

func validForgetArgs(args []string) bool {
	return len(args) == 0 || (len(args) == 1 && args[0] == "--dry-run")
}

// dispatchJobWithPayload is dispatchJob's variant that lets callers
// fill in structured fields (Includes/Excludes/Tag/ForgetGroups/RequiresAdminCreds)
// — used by the per-source-group Run-now path. JobID is filled in
// here; callers leave it zero on the input payload.
//
// sourceGroupID is the dedup key the alert engine will key on for
// backup_failed. Pass non-nil for backups; nil for prune/check/unlock
// (those are repo-scoped and dedup at host_id only).
func (s *Server) dispatchJobWithPayload(ctx context.Context, user *store.User,
	hostID string, kind api.JobKind, sourceGroupID *string, payload api.CommandRunPayload,
) (res runNowResponse, status int, code, msg string) {
	if !validJobKind(kind) {
		return res, stdhttp.StatusBadRequest, "invalid_kind",
			"kind must be one of backup|forget|prune|check|unlock"
	}
	host, err := s.deps.Store.GetHost(ctx, hostID)
	if err != nil {
		return res, stdhttp.StatusNotFound, "host_not_found", ""
	}
	if !s.deps.Hub.Connected(host.ID) {
		return res, stdhttp.StatusServiceUnavailable, "host_offline",
			"agent is not currently connected; try again when it reconnects"
	}

	jobID := ulid.Make().String()
	now := time.Now().UTC()
	var actorID *string
	actor := "system"
	if user != nil {
		actor = "user"
		actorID = &user.ID
	}
	if err := s.deps.Store.CreateJob(ctx, store.Job{
		ID:            jobID,
		HostID:        host.ID,
		Kind:          string(kind),
		SourceGroupID: sourceGroupID,
		ActorKind:     actor,
		ActorID:       actorID,
		CreatedAt:     now,
	}); err != nil {
		return res, stdhttp.StatusInternalServerError, "internal", ""
	}

	payload.JobID = jobID
	payload.Kind = kind
	env, err := api.Marshal(api.MsgCommandRun, jobID, payload)
	if err != nil {
		return res, stdhttp.StatusInternalServerError, "internal", ""
	}
	if err := s.deps.Hub.Send(ctx, host.ID, env); err != nil {
		return res, stdhttp.StatusServiceUnavailable, "host_offline", err.Error()
	}

	_ = s.deps.Store.AppendAudit(ctx, store.AuditEntry{
		ID:         ulid.Make().String(),
		UserID:     actorID,
		Actor:      actor,
		Action:     "job.run_now",
		TargetKind: ptr("job"),
		TargetID:   &jobID,
		TS:         now,
	})
	return runNowResponse{JobID: jobID, Status: "queued"}, 0, "", ""
}

// requireUser resolves the session cookie to a user row. Stub of the
// session-auth middleware that lands in P1-04's full pass.
func (s *Server) requireUser(r *stdhttp.Request) (*store.User, bool) {
	c, err := r.Cookie(sessionCookieName)
	if err != nil {
		return nil, false
	}
	sess, err := s.deps.Store.LookupSession(r.Context(), auth.HashToken(c.Value))
	if err != nil {
		return nil, false
	}
	u, err := s.deps.Store.GetUserByID(r.Context(), sess.UserID)
	if err != nil {
		return nil, false
	}
	if u.DisabledAt != nil {
		// Disabled mid-session — kill the session and reject the
		// request as if it were unauthenticated.
		_ = s.deps.Store.DeleteSession(r.Context(), auth.HashToken(c.Value))
		return nil, false
	}
	return u, true
}

func validJobKind(k api.JobKind) bool {
	switch k {
	case api.JobBackup, api.JobInit, api.JobForget, api.JobPrune,
		api.JobCheck, api.JobUnlock, api.JobRestore, api.JobDiff:
		return true
	}
	return false
}
