package handlers

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

	"github.com/go-chi/chi/v5"
)

type ChatHandler struct {
	chatService *service.ChatService
	userService *service.UserService
}

func NewChatHandler(chatService *service.ChatService, userService *service.UserService) *ChatHandler {
	return &ChatHandler{
		chatService: chatService,
		userService: userService,
	}
}

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

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

	if req.TargetLogin == "" {
		responses.BadRequest(w, "target_login is required")
		return
	}

	// Находим целевого пользователя по логину
	targetUser, err := h.userService.GetUserByLogin(r.Context(), req.TargetLogin)
	if err != nil {
		responses.NotFound(w, "target user not found")
		return
	}

	if targetUser == nil {
		responses.NotFound(w, "target user not found")
		return
	}

	// Создаем приватный чат
	chat, err := h.chatService.CreatePrivateChat(r.Context(), user.ID, targetUser.ID)
	if err != nil {
		responses.InternalServerError(w, err.Error())
		return
	}

	responses.Success(w, http.StatusCreated, chat)
}

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

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

	chat, err := h.chatService.CreateGroupChat(r.Context(), user.ID, req.Title, req.MemberLogins)
	if err != nil {
		responses.BadRequest(w, err.Error())
		return
	}

	responses.Success(w, http.StatusCreated, chat)
}

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

	chats, err := h.chatService.GetUserChatsWithDetails(r.Context(), user.ID)
	if err != nil {
		responses.InternalServerError(w, err.Error())
		return
	}

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

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

	chatID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid chat id")
		return
	}

	chat, err := h.chatService.GetChatByID(r.Context(), chatID, user.ID)
	if err != nil {
		responses.NotFound(w, err.Error())
		return
	}

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

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

	chatID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid chat id")
		return
	}

	members, err := h.chatService.GetChatMembers(r.Context(), chatID, user.ID)
	if err != nil {
		responses.Forbidden(w, err.Error())
		return
	}

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

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

	chatID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid chat id")
		return
	}

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

	if err := h.chatService.AddMembers(r.Context(), chatID, user.ID, req.UserLogins); err != nil {
		responses.BadRequest(w, err.Error())
		return
	}

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

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

	chatID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid chat id")
		return
	}

	memberID, err := strconv.ParseInt(chi.URLParam(r, "user_id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid member id")
		return
	}

	if err := h.chatService.RemoveMember(r.Context(), chatID, user.ID, memberID); err != nil {
		responses.BadRequest(w, err.Error())
		return
	}

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

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

	chatID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		responses.BadRequest(w, "invalid chat id")
		return
	}

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

	if err := h.chatService.UpdateChatTitle(r.Context(), chatID, user.ID, req.Title); err != nil {
		responses.BadRequest(w, err.Error())
		return
	}

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