package handler

import (
	"net/http"
	"time"

	"go.uber.org/zap"

	"github.com/dbiz/cdp/data-layer/api/internal/middleware"
	"github.com/dbiz/cdp/data-layer/api/internal/model"
	"github.com/dbiz/cdp/data-layer/api/internal/service"
)

type EventHandler struct {
	svc *service.QueryService
	log *zap.Logger
}

func NewEventHandler(svc *service.QueryService, log *zap.Logger) *EventHandler {
	return &EventHandler{svc: svc, log: log}
}

type queryEventsRequest struct {
	Table       string     `json:"table"        validate:"required,oneof=events_track events_identify events_page events_group"`
	From        *time.Time `json:"from"         validate:"required"`
	To          *time.Time `json:"to"           validate:"required,gtfield=From"`
	UserID      string     `json:"user_id"`
	AnonymousID string     `json:"anonymous_id"`
	EventName   string     `json:"event"`
	Limit       int        `json:"limit"        validate:"omitempty,min=1,max=1000"`
	Offset      int        `json:"offset"       validate:"omitempty,min=0"`
}

// QueryEvents handles POST /query/events.
func (h *EventHandler) QueryEvents(w http.ResponseWriter, r *http.Request) {
	var req queryEventsRequest
	if err := decodeAndValidate(r, &req); err != nil {
		writeError(w, err)
		return
	}
	if req.Limit == 0 {
		req.Limit = 100
	}

	ws := middleware.WorkspaceFromCtx(r.Context())
	res, err := h.svc.Events(r.Context(), model.EventQuery{
		WorkspaceID: ws,
		Table:       model.EventTable(req.Table),
		From:        *req.From,
		To:          *req.To,
		UserID:      req.UserID,
		AnonymousID: req.AnonymousID,
		EventName:   req.EventName,
		Limit:       req.Limit,
		Offset:      req.Offset,
	})
	if err != nil {
		h.log.Error("query events",
			zap.String("workspace_id", ws),
			zap.String("table", req.Table),
			zap.Error(err))
		writeError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, res)
}

// Health / Ready -- shared between all handlers but parked here for now.
func (h *EventHandler) Health(w http.ResponseWriter, _ *http.Request) {
	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (h *EventHandler) Ready(w http.ResponseWriter, _ *http.Request) {
	writeJSON(w, http.StatusOK, map[string]string{"status": "ready"})
}