package settings

import (
	"RenewCMS/api/pkg/apperr"
	validator "RenewCMS/api/pkg/validator"
	"RenewCMS/internal/domain/audit"
	"RenewCMS/internal/infrastructure/useCases"
	"encoding/json"
	"errors"
	"net/http"
	"time"
)

type Handler struct {
	GetSettingsUseCase             *useCases.GetSettingsUseCase
	GetActivityRetentionUseCase    *useCases.GetActivityRetentionUseCase
	UpdateActivityRetentionUseCase *useCases.UpdateActivityRetentionUseCase
}

type UpdateSettingsRequest struct {
	ActivityRetentionDays *int `json:"activity_retention_days" validate:"required,oneof=0 30 90 365"`
}

type settingsResponse struct {
	Version                    string     `json:"version"`
	ActivityRetentionDays      int        `json:"activity_retention_days"`
	ActivityLastCleanupAt      *time.Time `json:"activity_last_cleanup_at"`
	ActivityLastCleanupRemoved int        `json:"activity_last_cleanup_removed"`
	ActivityNextCleanupAt      *time.Time `json:"activity_next_cleanup_at"`
}

func NewHandler(getSettings *useCases.GetSettingsUseCase, getRetention *useCases.GetActivityRetentionUseCase, updateRetention *useCases.UpdateActivityRetentionUseCase) *Handler {
	return &Handler{GetSettingsUseCase: getSettings, GetActivityRetentionUseCase: getRetention, UpdateActivityRetentionUseCase: updateRetention}
}

func (h *Handler) GetSettings(w http.ResponseWriter, _ *http.Request) {
	retention, err := h.GetActivityRetentionUseCase.GetActivityRetention()
	if err != nil {
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
	h.write(w, retention)
}

func (h *Handler) UpdateSettings(w http.ResponseWriter, r *http.Request) {
	var request UpdateSettingsRequest
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
		http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
		return
	}
	if err := validator.Validate.Struct(request); err != nil {
		http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
		return
	}

	retention, err := h.UpdateActivityRetentionUseCase.UpdateActivityRetention(r.Context(), *request.ActivityRetentionDays)
	if err != nil {
		if errors.Is(err, audit.ErrInvalidRetention) {
			http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
			return
		}
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
	h.write(w, retention)
}

func (h *Handler) write(w http.ResponseWriter, retention audit.Settings) {
	body, err := json.Marshal(settingsResponse{
		Version:                    h.GetSettingsUseCase.GetSettings().Version,
		ActivityRetentionDays:      retention.RetentionDays,
		ActivityLastCleanupAt:      retention.LastCleanupAt,
		ActivityLastCleanupRemoved: retention.LastCleanupRemoved,
		ActivityNextCleanupAt:      retention.NextCleanupAt,
	})
	if err != nil {
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
	_, _ = w.Write(body)
}