package handlers

import (
    "encoding/json"
    "net/http"
    
    "github.com/go-chi/chi/v5"
    "go-rest-api/internal/models"
    "go-rest-api/internal/service"
)

type AuthHandler struct {
    authService service.AuthService
}

func NewAuthHandler(authService service.AuthService) *AuthHandler {
    return &AuthHandler{authService: authService}
}

func (h *AuthHandler) Routes() chi.Router {
    r := chi.NewRouter()
    
    r.Post("/register", h.Register)
    r.Post("/login", h.Login)
    r.Get("/check", h.AuthCheck)
    
    return r
}

type RegisterRequest struct {
    Email     string `json:"email"`
    Password  string `json:"password"`
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
}

type LoginRequest struct {
    Email    string `json:"email"`
    Password string `json:"password"`
}

func (h *AuthHandler) Register(w http.ResponseWriter, r *http.Request) {
    var req RegisterRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        respondWithError(w, http.StatusBadRequest, "Invalid request payload")
        return
    }
    
    user := &models.User{
        Email:     req.Email,
        Password:  req.Password,
        FirstName: req.FirstName,
        LastName:  req.LastName,
        Role:      "user",
    }
    
    if err := h.authService.Register(user); err != nil {
        respondWithError(w, http.StatusBadRequest, err.Error())
        return
    }
    
    respondWithJSON(w, http.StatusCreated, map[string]string{
        "message": "User registered successfully",
    })
}

func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
    var req LoginRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        respondWithError(w, http.StatusBadRequest, "Invalid request payload")
        return
    }
    
    user, err := h.authService.Login(req.Email, req.Password)
    if err != nil {
        respondWithError(w, http.StatusUnauthorized, err.Error())
        return
    }
    
    respondWithJSON(w, http.StatusOK, map[string]interface{}{
        "message": "Login successful",
        "user": map[string]interface{}{
            "id":         user.ID,
            "email":      user.Email,
            "first_name": user.FirstName,
            "last_name":  user.LastName,
            "role":       user.Role,
        },
    })
}

func (h *AuthHandler) AuthCheck(w http.ResponseWriter, r *http.Request) {
    respondWithJSON(w, http.StatusOK, map[string]string{
        "status":  "ok",
        "message": "Auth endpoint is working",
    })
}