package handlers

import (
	"encoding/json"
	"net/http"
	"prak-03-todo/internal/db"
	"strconv"

	"github.com/gorilla/mux"
)

// CreateTaskHandler handles POST /groups/{groupId}/tasks
func CreateTaskHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupID, err := strconv.Atoi(vars["groupId"])
	if err != nil {
		http.Error(w, "Invalid group ID", http.StatusBadRequest)
		return
	}

	var taskRequest struct {
		TaskName        string  `json:"task_name"`
		TaskDescription *string `json:"task_description,omitempty"`
	}

	err = json.NewDecoder(r.Body).Decode(&taskRequest)
	if err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	// Validate input
	if taskRequest.TaskName == "" {
		http.Error(w, "Task name is required", http.StatusBadRequest)
		return
	}

	// Verify group exists
	_, err = db.GetGroupByID(groupID)
	if err != nil {
		if err.Error() == "group not found" {
			http.Error(w, "Group not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to verify group", http.StatusInternalServerError)
		return
	}

	// Create task using query function
	task, err := db.CreateTask(taskRequest.TaskName, taskRequest.TaskDescription, groupID)
	if err != nil {
		http.Error(w, "Failed to create task", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(task)
}

// DisplayTasksHandler handles GET /tasks
func DisplayTasksHandler(w http.ResponseWriter, r *http.Request) {
	tasks, err := db.GetAllTasks()
	if err != nil {
		http.Error(w, "Failed to fetch tasks", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(tasks)
}

// DisplayTasksByGroupHandler handles GET /groups/{groupId}/tasks
func DisplayTasksByGroupHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupID, err := strconv.Atoi(vars["groupId"])
	if err != nil {
		http.Error(w, "Invalid group ID", http.StatusBadRequest)
		return
	}

	// Verify group exists
	_, err = db.GetGroupByID(groupID)
	if err != nil {
		if err.Error() == "group not found" {
			http.Error(w, "Group not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to verify group", http.StatusInternalServerError)
		return
	}

	// Get tasks for the group
	tasks, err := db.GetTasksByGroupID(groupID)
	if err != nil {
		http.Error(w, "Failed to fetch tasks", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(tasks)
}

// GetTaskHandler handles GET /tasks/{taskId}
func GetTaskHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	taskID, err := strconv.Atoi(vars["taskId"])
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}

	task, err := db.GetTaskByID(taskID)
	if err != nil {
		if err.Error() == "task not found" {
			http.Error(w, "Task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to fetch task", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(task)
}

// UpdateTaskHandler handles PUT /tasks/{taskId}
func UpdateTaskHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	taskID, err := strconv.Atoi(vars["taskId"])
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}

	var taskRequest struct {
		TaskName        string  `json:"task_name"`
		TaskDescription *string `json:"task_description,omitempty"`
	}

	err = json.NewDecoder(r.Body).Decode(&taskRequest)
	if err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	// Validate input
	if taskRequest.TaskName == "" {
		http.Error(w, "Task name is required", http.StatusBadRequest)
		return
	}

	// Update task using query function
	err = db.UpdateTask(taskID, taskRequest.TaskName, taskRequest.TaskDescription)
	if err != nil {
		if err.Error() == "task not found" {
			http.Error(w, "Task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to update task", http.StatusInternalServerError)
		return
	}

	// Get updated task
	task, err := db.GetTaskByID(taskID)
	if err != nil {
		http.Error(w, "Failed to fetch updated task", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(task)
}

// MarkTaskDoneHandler handles PUT /tasks/{taskId}/done
func MarkTaskDoneHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	taskID, err := strconv.Atoi(vars["taskId"])
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}

	err = db.MarkTaskDone(taskID)
	if err != nil {
		if err.Error() == "task not found" {
			http.Error(w, "Task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to mark task as done", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Task ID " + vars["taskId"] + " Marked as Done"))
}

// RemoveTaskHandler handles DELETE /tasks/{taskId}
func RemoveTaskHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	taskID, err := strconv.Atoi(vars["taskId"])
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}

	err = db.DeleteTask(taskID)
	if err != nil {
		if err.Error() == "task not found" {
			http.Error(w, "Task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to delete task", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Task ID " + vars["taskId"] + " Removed"))
}