package handlers

import (
	"context"
	"encoding/json"
	"messenger/internal/api/middleware"
	"messenger/internal/api/responses"
	"messenger/internal/models"
	"messenger/internal/service"
	"net/http"
	"strconv"
)

type UserHandler struct {
	userService *service.UserService
}

func NewUserHandler(userService *service.UserService) *UserHandler {
	return &UserHandler{userService: userService}
}

type UpdateProfileRequest struct {
	DisplayName *string `json:"display_name,omitempty"`
	Bio         *string `json:"bio,omitempty"`
}

func (h *UserHandler) GetProfile(w http.ResponseWriter, r *http.Request) {
	user := middleware.GetUserFromContext(r.Context())
	if user == nil {
		responses.Unauthorized(w, "user not found")
		return
	}

	profile, err := h.userService.GetProfile(r.Context(), user.ID)
	if err != nil {
		responses.NotFound(w, err.Error())
		return
	}

	responses.Success(w, http.StatusOK, profile)
}

func (h *UserHandler) UpdateProfile(w http.ResponseWriter, r *http.Request) {
	user := middleware.GetUserFromContext(r.Context())
	if user == nil {
		responses.Unauthorized(w, "user not found")
		return
	}

	var req UpdateProfileRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		responses.BadRequest(w, "invalid request body")
		return
	}

	if err := h.userService.UpdateProfile(r.Context(), user.ID, req.DisplayName, req.Bio); err != nil {
		responses.BadRequest(w, err.Error())
		return
	}

	responses.Success(w, http.StatusOK, map[string]string{"message": "profile updated"})
}

func (h *UserHandler) SearchUsers(w http.ResponseWriter, r *http.Request) {
	query := r.URL.Query().Get("q")
	if query == "" {
		responses.BadRequest(w, "search query required")
		return
	}

	limit := 20
	if l := r.URL.Query().Get("limit"); l != "" {
		if parsed, err := strconv.Atoi(l); err == nil && parsed > 0 && parsed <= 100 {
			limit = parsed
		}
	}

	users, err := h.userService.SearchUsers(r.Context(), query, limit)
	if err != nil {
		responses.InternalServerError(w, err.Error())
		return
	}

	responses.Success(w, http.StatusOK, users)
}

func (h *UserHandler) GetUserByID(w http.ResponseWriter, r *http.Request) {
	// Реализация с chi.URLParam будет в main.go
	// Пока заглушка
	responses.Success(w, http.StatusOK, nil)
}

// GetUserByLoginFromContext - метод для получения пользователя по логину (используется в других хендлерах)
func (h *UserHandler) GetUserByLogin(ctx context.Context, login string) (*models.SafeUser, error) {
	user, err := h.userService.GetUserByLogin(ctx, login)
	if err != nil {
		return nil, err
	}
	if user == nil {
		return nil, nil
	}
	return user.ToSafe(), nil
}