path: root/backend/internal/api/handlers/goal_handler.go

package handlers

import (
	"log"
	"net/http"
	"strconv"
	"time"

	"finance/backend/internal/core"
	"finance/backend/internal/database"
	"finance/backend/internal/models"

	"github.com/gin-gonic/gin"
)

// CreateGoalInput defines the structure for creating a new financial goal
type CreateGoalInput struct {
	Name          string `json:"name" binding:"required"`
	TargetAmount  int64  `json:"targetAmount" binding:"required"`
	CurrentAmount int64  `json:"currentAmount"`
	TargetDate    string `json:"targetDate"` // YYYY-MM-DD format
	Status        string `json:"status"`
}

// UpdateGoalInput defines the structure for updating an existing financial goal
type UpdateGoalInput struct {
	Name          string `json:"name"`
	TargetAmount  int64  `json:"targetAmount"`
	CurrentAmount int64  `json:"currentAmount"`
	TargetDate    string `json:"targetDate"` // YYYY-MM-DD format
	Status        string `json:"status"`
}

// UpdateGoalProgressInput defines the structure for updating just the progress of a goal
type UpdateGoalProgressInput struct {
	CurrentAmount int64 `json:"currentAmount" binding:"required"`
}

// LinkTransactionInput defines the structure for linking a transaction to a goal
type LinkTransactionInput struct {
	TransactionID uint `json:"transactionId" binding:"required"`
}

// GoalHandler handles all goal-related operations in the API
type GoalHandler struct {
	goalService *core.GoalService
}

// NewGoalHandler creates and returns a new GoalHandler instance
func NewGoalHandler() *GoalHandler {
	return &GoalHandler{
		goalService: core.NewGoalService(),
	}
}

// GetGoals retrieves all goals for the authenticated user
// Optionally filtered by status if provided as a query parameter
func (h *GoalHandler) GetGoals(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	var goals []models.Goal

	query := database.DB.Where("user_id = ?", userID)

	// Filter by status if provided
	status := c.Query("status")
	if status != "" {
		query = query.Where("status = ?", status)
	}

	if err := query.Find(&goals).Error; err != nil {
		log.Printf("Error fetching goals for user %d: %v", userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get goals"})
		return
	}

	c.JSON(http.StatusOK, goals)
}

// GetGoal retrieves a specific goal by ID for the authenticated user
func (h *GoalHandler) GetGoal(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	c.JSON(http.StatusOK, goal)
}

// CreateGoal creates a new financial goal for the authenticated user
func (h *GoalHandler) CreateGoal(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	var input CreateGoalInput

	if err := c.ShouldBindJSON(&input); err != nil {
		log.Printf("Error binding JSON for goal creation: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Set default status if not provided
	status := "Active"
	if input.Status != "" {
		status = input.Status
	}

	// Parse target date if provided
	var targetDate time.Time
	if input.TargetDate != "" {
		parsedDate, err := time.Parse("2006-01-02", input.TargetDate)
		if err != nil {
			log.Printf("Error parsing target date for goal creation: %v", err)
			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid date format for targetDate. Use YYYY-MM-DD"})
			return
		}
		targetDate = parsedDate
	}

	goal := models.Goal{
		UserID:        userID,
		Name:          input.Name,
		TargetAmount:  input.TargetAmount,
		CurrentAmount: input.CurrentAmount,
		Status:        status,
	}

	// Only set target date if it was provided
	if !targetDate.IsZero() {
		goal.TargetDate = targetDate
	}

	if err := database.DB.Create(&goal).Error; err != nil {
		log.Printf("Error creating goal for user %d: %v", userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create goal"})
		return
	}

	log.Printf("Goal created successfully for user %d: %s (ID: %d)", userID, goal.Name, goal.ID)
	c.JSON(http.StatusCreated, goal)
}

// UpdateGoal updates an existing goal for the authenticated user
func (h *GoalHandler) UpdateGoal(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID for update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d in update: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	var input UpdateGoalInput
	if err := c.ShouldBindJSON(&input); err != nil {
		log.Printf("Error binding JSON for goal update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Update fields that were provided
	if input.Name != "" {
		goal.Name = input.Name
	}
	if input.TargetAmount != 0 {
		goal.TargetAmount = input.TargetAmount
	}
	if input.CurrentAmount != 0 {
		goal.CurrentAmount = input.CurrentAmount
	}
	if input.TargetDate != "" {
		parsedDate, err := time.Parse("2006-01-02", input.TargetDate)
		if err != nil {
			log.Printf("Error parsing target date for goal update: %v", err)
			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid date format for targetDate. Use YYYY-MM-DD"})
			return
		}
		goal.TargetDate = parsedDate
	}
	if input.Status != "" {
		goal.Status = input.Status
	}

	// Check if goal has been achieved
	if goal.CurrentAmount >= goal.TargetAmount {
		goal.Status = "Achieved"
		log.Printf("Goal ID %d for user %d automatically marked as Achieved", goalID, userID)
	}

	if err := database.DB.Save(&goal).Error; err != nil {
		log.Printf("Error saving updated goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update goal"})
		return
	}

	log.Printf("Goal ID %d updated successfully for user %d", goalID, userID)
	c.JSON(http.StatusOK, goal)
}

// UpdateGoalProgress updates just the progress (current amount) of a goal
func (h *GoalHandler) UpdateGoalProgress(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID for progress update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d in progress update: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	var input UpdateGoalProgressInput
	if err := c.ShouldBindJSON(&input); err != nil {
		log.Printf("Error binding JSON for goal progress update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	goal.CurrentAmount = input.CurrentAmount

	// Check if goal has been achieved
	if goal.CurrentAmount >= goal.TargetAmount {
		goal.Status = "Achieved"
		log.Printf("Goal ID %d for user %d automatically marked as Achieved during progress update", goalID, userID)
	}

	if err := database.DB.Save(&goal).Error; err != nil {
		log.Printf("Error saving progress update for goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update goal progress"})
		return
	}

	log.Printf("Goal ID %d progress updated successfully for user %d: %d/%d", goalID, userID, goal.CurrentAmount, goal.TargetAmount)
	c.JSON(http.StatusOK, goal)
}

// DeleteGoal deletes a goal belonging to the authenticated user
func (h *GoalHandler) DeleteGoal(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID for deletion: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d for deletion: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	if err := database.DB.Delete(&goal).Error; err != nil {
		log.Printf("Error deleting goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete goal"})
		return
	}

	log.Printf("Goal ID %d deleted successfully for user %d", goalID, userID)
	c.JSON(http.StatusOK, gin.H{"message": "Goal deleted successfully"})
}

// GetGoalProgressDetails retrieves a goal with detailed progress information
func (h *GoalHandler) GetGoalProgressDetails(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	progress, err := h.goalService.GetGoalProgress(userID, uint(goalID))
	if err != nil {
		log.Printf("Error fetching goal progress for ID %d, user %d: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	c.JSON(http.StatusOK, progress)
}

// GetAllGoalsProgressDetails retrieves all goals with enhanced progress details
func (h *GoalHandler) GetAllGoalsProgressDetails(c *gin.Context) {
	userID := c.MustGet("userID").(uint)

	// Filter by status if provided
	status := c.Query("status")

	progress, err := h.goalService.GetAllGoalsProgress(userID, status)
	if err != nil {
		log.Printf("Error fetching all goals progress for user %d: %v", userID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get goal progress"})
		return
	}

	c.JSON(http.StatusOK, progress)
}

// LinkTransactionToGoal links a transaction to a specific goal
func (h *GoalHandler) LinkTransactionToGoal(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	var input LinkTransactionInput
	if err := c.ShouldBindJSON(&input); err != nil {
		log.Printf("Error binding JSON for linking transaction: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Verify the goal belongs to the user
	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	// Verify the transaction belongs to the user
	var transaction models.Transaction
	if err := database.DB.Where("id = ? AND user_id = ?", input.TransactionID, userID).First(&transaction).Error; err != nil {
		log.Printf("Error fetching transaction ID %d for user %d: %v", input.TransactionID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Transaction not found"})
		return
	}

	// Link the transaction to the goal
	if err := h.goalService.LinkTransactionToGoal(input.TransactionID, uint(goalID)); err != nil {
		log.Printf("Error linking transaction %d to goal %d: %v", input.TransactionID, goalID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to link transaction to goal"})
		return
	}

	log.Printf("Transaction ID %d successfully linked to goal ID %d for user %d", input.TransactionID, goalID, userID)
	c.JSON(http.StatusOK, gin.H{"message": "Transaction linked to goal successfully"})
}

// RecalculateGoalProgress recalculates a goal's progress based on linked transactions
func (h *GoalHandler) RecalculateGoalProgress(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	goalID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		log.Printf("Error parsing goal ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid goal ID"})
		return
	}

	// Verify the goal belongs to the user
	var goal models.Goal
	if err := database.DB.Where("id = ? AND user_id = ?", goalID, userID).First(&goal).Error; err != nil {
		log.Printf("Error fetching goal ID %d for user %d: %v", goalID, userID, err)
		c.JSON(http.StatusNotFound, gin.H{"error": "Goal not found"})
		return
	}

	// Recalculate the goal progress
	if err := h.goalService.UpdateGoalFromTransactions(uint(goalID)); err != nil {
		log.Printf("Error recalculating goal progress for ID %d: %v", goalID, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to recalculate goal progress"})
		return
	}

	// Fetch the updated goal to return in response
	if err := database.DB.First(&goal, goalID).Error; err != nil {
		log.Printf("Error fetching updated goal after recalculation: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch updated goal"})
		return
	}

	log.Printf("Goal ID %d progress recalculated successfully for user %d", goalID, userID)
	c.JSON(http.StatusOK, goal)
}