TaskApiHandler.java

package com.strms.web;

import com.strms.controller.TaskManager;
import com.strms.enums.PriorityLevel;
import com.strms.enums.TaskCategory;
import com.strms.exceptions.DuplicateTaskException;
import com.strms.exceptions.InvalidRoleException;
import com.strms.exceptions.InvalidTaskStateException;
import com.strms.exceptions.TaskNotFoundException;
import com.strms.model.Admin;
import com.strms.model.Engineer;
import com.strms.model.Manager;
import com.strms.model.Task;
import com.strms.model.User;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * Handles all /api/* requests for the STRMS web interface.
 * Returns JSON responses, accepts JSON POST bodies.
 */
public class TaskApiHandler implements HttpHandler {

    private static final User WEB_ADMIN = new Admin("WEB", "Web User", "web@strms.local");

    private final TaskManager taskManager;

    public TaskApiHandler(TaskManager taskManager) {
        this.taskManager = taskManager;
    }

    @Override
    public void handle(HttpExchange exchange) throws IOException {
        String path   = exchange.getRequestURI().getPath();
        String method = exchange.getRequestMethod();

        addCorsHeaders(exchange);

        if ("OPTIONS".equals(method)) {
            sendResponse(exchange, 204, "");
            return;
        }

        try {
            if (path.equals("/api/stats") && "GET".equals(method)) {
                handleGetStats(exchange);
            } else if (path.equals("/api/users") && "GET".equals(method)) {
                handleGetUsers(exchange);
            } else if (path.equals("/api/tasks") && "GET".equals(method)) {
                handleGetTasks(exchange);
            } else if (path.equals("/api/tasks") && "POST".equals(method)) {
                handleCreateTask(exchange);
            } else if (path.equals("/api/tasks/assign") && "POST".equals(method)) {
                handleAssignTask(exchange);
            } else if (path.equals("/api/tasks/start") && "POST".equals(method)) {
                handleStartTask(exchange);
            } else if (path.equals("/api/tasks/complete") && "POST".equals(method)) {
                handleCompleteTask(exchange);
            } else if (path.equals("/api/tasks/delete") && "POST".equals(method)) {
                handleDeleteTask(exchange);
            } else if (path.equals("/api/users") && "POST".equals(method)) {
                handleCreateUser(exchange);
            } else if (path.equals("/api/users/delete") && "POST".equals(method)) {
                handleDeleteUser(exchange);
            } else if (path.equals("/api/auth/login") && "POST".equals(method)) {
                handleLogin(exchange);
            } else if (path.equals("/api/tasks/update") && "POST".equals(method)) {
                handleUpdateTask(exchange);
            } else if (path.equals("/api/tasks/dependency/add") && "POST".equals(method)) {
                handleAddDependency(exchange);
            } else if (path.equals("/api/tasks/dependency/remove") && "POST".equals(method)) {
                handleRemoveDependency(exchange);
            } else {
                sendResponse(exchange, 404, "{\"error\":\"Route non trouvee\"}");
            }
        } catch (Exception e) {
            sendResponse(exchange, 500, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── GET /api/tasks ────────────────────────────────────────────────────────
    private void handleGetTasks(HttpExchange exchange) throws IOException {
        Collection<Task> tasks = taskManager.getAllTasks();
        StringBuilder sb = new StringBuilder("[");
        boolean first = true;
        for (Task t : tasks) {
            if (!first) sb.append(",");
            first = false;
            sb.append(taskToJson(t));
        }
        sb.append("]");
        sendJson(exchange, 200, sb.toString());
    }

    // ── GET /api/stats ────────────────────────────────────────────────────────
    private void handleGetStats(HttpExchange exchange) throws IOException {
        Collection<Task> tasks = taskManager.getAllTasks();
        int total = tasks.size();
        int done = 0, inProgress = 0, todo = 0, blocked = 0, overdue = 0;
        for (Task t : tasks) {
            switch (t.getStatus()) {
                case DONE        -> done++;
                case IN_PROGRESS -> inProgress++;
                case TODO        -> todo++;
                case BLOCKED     -> blocked++;
            }
            if (t.isOverdue()) overdue++;
        }
        int pct = total == 0 ? 0 : (done * 100 / total);
        String json = "{"
                + "\"total\":"      + total      + ","
                + "\"done\":"       + done        + ","
                + "\"inProgress\":" + inProgress  + ","
                + "\"todo\":"       + todo        + ","
                + "\"blocked\":"    + blocked     + ","
                + "\"overdue\":"    + overdue     + ","
                + "\"completion\":" + pct
                + "}";
        sendJson(exchange, 200, json);
    }

    // ── GET /api/users ────────────────────────────────────────────────────────
    private void handleGetUsers(HttpExchange exchange) throws IOException {
        Collection<User> users = taskManager.getAllUsers();
        StringBuilder sb = new StringBuilder("[");
        boolean first = true;
        for (User u : users) {
            if (!first) sb.append(",");
            first = false;
            sb.append("{\"id\":\"").append(escape(u.getId())).append("\",")
              .append("\"name\":\"").append(escape(u.getName())).append("\",")
              .append("\"role\":\"").append(escape(u.getRole())).append("\"}");
        }
        sb.append("]");
        sendJson(exchange, 200, sb.toString());
    }

    // ── POST /api/tasks ───────────────────────────────────────────────────────
    private void handleCreateTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String id    = body.getOrDefault("id", "");
        String title = body.getOrDefault("title", "");
        String desc  = body.getOrDefault("description", "");
        String pl    = body.getOrDefault("priority", "MEDIUM");
        String cat   = body.getOrDefault("category", "FEATURE");
        String dl    = body.getOrDefault("deadline", "");

        if (id.isBlank() || title.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"id et title sont obligatoires\"}");
            return;
        }
        LocalDate deadline = dl.isBlank() ? null : LocalDate.parse(dl);
        Task task = new Task(id, title, desc,
                PriorityLevel.valueOf(pl),
                TaskCategory.valueOf(cat),
                deadline);
        try {
            taskManager.addTask(task, WEB_ADMIN);
            sendJson(exchange, 201, "{\"message\":\"Tache creee\",\"id\":\"" + escape(id) + "\"}");
        } catch (InvalidRoleException | DuplicateTaskException e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/assign ────────────────────────────────────────────────
    private void handleAssignTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "");
        String userId = body.getOrDefault("userId", "");
        try {
            taskManager.assignTask(taskId, userId, WEB_ADMIN);
            sendJson(exchange, 200, "{\"message\":\"Tache assignee\"}");
        } catch (InvalidRoleException | TaskNotFoundException e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/start ─────────────────────────────────────────────────
    private void handleStartTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "");
        try {
            taskManager.startTask(taskId, WEB_ADMIN);
            sendJson(exchange, 200, "{\"message\":\"Tache demarree\"}");
        } catch (Exception e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/complete ──────────────────────────────────────────────
    private void handleCompleteTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "");
        try {
            taskManager.completeTask(taskId, WEB_ADMIN);
            sendJson(exchange, 200, "{\"message\":\"Tache terminee\"}");
        } catch (TaskNotFoundException | InvalidTaskStateException e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/delete ────────────────────────────────────────────────
    private void handleDeleteTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "");
        try {
            taskManager.deleteTask(taskId, WEB_ADMIN);
            sendJson(exchange, 200, "{\"message\":\"Tache supprimee\"}");
        } catch (Exception e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/users ───────────────────────────────────────────────────────
    private void handleCreateUser(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String id    = body.getOrDefault("id", "").trim();
        String name  = body.getOrDefault("name", "").trim();
        String email = body.getOrDefault("email", "").trim();
        String role  = body.getOrDefault("role", "Engineer").trim();
        String pass  = body.getOrDefault("password", "").trim();

        if (id.isBlank() || name.isBlank() || email.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"id, name et email sont obligatoires\"}");
            return;
        }
        if (taskManager.getAllUsers().stream().anyMatch(u -> u.getId().equals(id))) {
            sendJson(exchange, 400, "{\"error\":\"Un utilisateur avec cet ID existe deja\"}");
            return;
        }

        User user = switch (role) {
            case "Admin"   -> new Admin(id, name, email);
            case "Manager" -> new Manager(id, name, email);
            default        -> new Engineer(id, name, email);
        };
        if (!pass.isBlank()) user.setPassword(pass);
        taskManager.addUser(user);
        try { taskManager.saveUsersToFile("strms_users.csv"); } catch (Exception ignored) {}
        sendJson(exchange, 201, "{\"message\":\"Utilisateur cree\",\"id\":\"" + escape(id) + "\"}");
    }

    // ── POST /api/users/delete ────────────────────────────────────────────────
    private void handleDeleteUser(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String id = body.getOrDefault("id", "").trim();
        if (id.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"id est obligatoire\"}");
            return;
        }
        boolean removed = taskManager.removeUser(id);
        if (!removed) {
            sendJson(exchange, 404, "{\"error\":\"Utilisateur introuvable\"}");
            return;
        }
        try { taskManager.saveUsersToFile("strms_users.csv"); } catch (Exception ignored) {}
        sendJson(exchange, 200, "{\"message\":\"Utilisateur supprime\"}");
    }

    // ── POST /api/auth/login ──────────────────────────────────────────────────
    private void handleLogin(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String name = body.getOrDefault("name", "").trim();
        String pass = body.getOrDefault("password", "").trim();

        if (name.isBlank() || pass.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"name et password sont obligatoires\"}");
            return;
        }

        User found = taskManager.getAllUsers().stream()
                .filter(u -> u.getName().equalsIgnoreCase(name))
                .findFirst().orElse(null);

        if (found == null) {
            sendJson(exchange, 401, "{\"error\":\"Utilisateur introuvable\"}");
            return;
        }

        if (!found.checkPassword(pass)) {
            sendJson(exchange, 401, "{\"error\":\"Mot de passe incorrect\"}");
            return;
        }

        sendJson(exchange, 200,
            "{\"name\":\"" + escape(found.getName()) + "\"," +
            "\"role\":\"" + escape(found.getRole()) + "\"," +
            "\"id\":\""   + escape(found.getId())   + "\"}");
    }

    // ── POST /api/tasks/update ────────────────────────────────────────────────
    private void handleUpdateTask(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "").trim();
        if (taskId.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"taskId est obligatoire\"}");
            return;
        }

        try {
            // Validation explicite demandee : ID inconnu => 404, pas 400/500.
            taskManager.findTask(taskId);
        } catch (TaskNotFoundException e) {
            sendJson(exchange, 404, "{\"error\":\"Task not found\"}");
            return;
        }

        String title    = body.getOrDefault("title", "").trim();
        String desc     = body.getOrDefault("description", "").trim();
        String pl       = body.getOrDefault("priority", "").trim();
        String cat      = body.getOrDefault("category", "").trim();
        String dl       = body.getOrDefault("deadline", "").trim();

        PriorityLevel priority;
        TaskCategory  category;
        LocalDate     deadline;
        try {
            priority = pl.isBlank()  ? null : PriorityLevel.valueOf(pl);
            category = cat.isBlank() ? null : TaskCategory.valueOf(cat);
            deadline = dl.isBlank()  ? null : LocalDate.parse(dl);
        } catch (Exception e) {
            sendJson(exchange, 400, "{\"error\":\"Invalid input value\"}");
            return;
        }

        try {
            taskManager.updateTask(taskId,
                    title.isBlank()    ? null : title,
                    desc.isBlank()     ? null : desc,
                    priority, category, deadline, WEB_ADMIN);
            sendJson(exchange, 200, "{\"message\":\"Tache mise a jour\"}");
        } catch (TaskNotFoundException e) {
            sendJson(exchange, 404, "{\"error\":\"Task not found\"}");
        } catch (InvalidRoleException e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/dependency/add ────────────────────────────────────────
    private void handleAddDependency(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "").trim();
        String depId  = body.getOrDefault("depId",  "").trim();
        if (taskId.isBlank() || depId.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"taskId et depId sont obligatoires\"}");
            return;
        }
        try {
            // Validation explicite : verifier les deux IDs avant modification.
            taskManager.findTask(taskId);
            taskManager.findTask(depId);
            taskManager.addDependency(taskId, depId);
            sendJson(exchange, 200, "{\"message\":\"Dependance ajoutee\"}");
        } catch (TaskNotFoundException e) {
            sendJson(exchange, 404, "{\"error\":\"Task not found\"}");
        } catch (Exception e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── POST /api/tasks/dependency/remove ─────────────────────────────────────
    private void handleRemoveDependency(HttpExchange exchange) throws IOException {
        Map<String, String> body = parseBody(exchange);
        String taskId = body.getOrDefault("taskId", "").trim();
        String depId  = body.getOrDefault("depId",  "").trim();
        if (taskId.isBlank() || depId.isBlank()) {
            sendJson(exchange, 400, "{\"error\":\"taskId et depId sont obligatoires\"}");
            return;
        }
        try {
            // Validation explicite : verifier les deux IDs avant modification.
            taskManager.findTask(taskId);
            taskManager.findTask(depId);
            taskManager.removeDependency(taskId, depId);
            sendJson(exchange, 200, "{\"message\":\"Dependance supprimee\"}");
        } catch (TaskNotFoundException e) {
            sendJson(exchange, 404, "{\"error\":\"Task not found\"}");
        } catch (Exception e) {
            sendJson(exchange, 400, "{\"error\":\"" + escape(e.getMessage()) + "\"}");
        }
    }

    // ── Helpers ───────────────────────────────────────────────────────────────

    private String taskToJson(Task t) {
        String assignee   = t.getAssignedTo() != null ? t.getAssignedTo().getName() : "";
        String assigneeId = t.getAssignedTo() != null ? t.getAssignedTo().getId()   : "";
        String deadline   = t.getDeadline() != null ? t.getDeadline().toString() : "";
        String dependencies = dependenciesToJson(t);

        return "{"
                + "\"id\":\""           + escape(t.getId())                    + "\","
                + "\"title\":\""        + escape(t.getTitle())                 + "\","
                + "\"description\":\""  + escape(t.getDescription())           + "\","
                + "\"status\":\""       + t.getStatus().name()                 + "\","
                + "\"priority\":\""     + t.getPriorityLevel().name()          + "\","
                + "\"category\":\""     + t.getCategory().name()               + "\","
                + "\"deadline\":\""     + deadline                             + "\","
                + "\"assignedTo\":\""   + escape(assignee)                     + "\","
                + "\"assignedToId\":\"" + escape(assigneeId)                   + "\","
                + "\"dependencies\":"      + dependencies                         + ","
                + "\"isBlocked\":"         + t.isBlocked()                        + ","
                + "\"isOverdue\":"         + t.isOverdue()
                + "}";
    }

    private String dependenciesToJson(Task t) {
        StringBuilder sb = new StringBuilder("[");
        boolean first = true;
        for (Task dep : t.getDependencies()) {
            if (!first) sb.append(",");
            first = false;
            sb.append("\"").append(escape(dep.getId())).append("\"");
        }
        sb.append("]");
        return sb.toString();
    }

    private Map<String, String> parseBody(HttpExchange exchange) throws IOException {
        Map<String, String> map = new HashMap<>();
        try (InputStream is = exchange.getRequestBody()) {
            String body = new String(is.readAllBytes(), StandardCharsets.UTF_8).trim();
            // Robust JSON parser: extract "key":"value" pairs (handles spaces in values)
            java.util.regex.Matcher m = java.util.regex.Pattern
                .compile("\"([^\"]+)\"\\s*:\\s*\"([^\"]*)\"")
                .matcher(body);
            while (m.find()) {
                map.put(m.group(1), m.group(2));
            }
            // Also handle "key":true/false/number (unquoted values)
            java.util.regex.Matcher m2 = java.util.regex.Pattern
                .compile("\"([^\"]+)\"\\s*:\\s*([^,}\"\\s]+)")
                .matcher(body);
            while (m2.find()) {
                map.putIfAbsent(m2.group(1), m2.group(2));
            }
        }
        return map;
    }

    private void addCorsHeaders(HttpExchange exchange) {
        exchange.getResponseHeaders().add("Access-Control-Allow-Origin", "*");
        exchange.getResponseHeaders().add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
        exchange.getResponseHeaders().add("Access-Control-Allow-Headers", "Content-Type");
    }

    private void sendJson(HttpExchange exchange, int code, String json) throws IOException {
        exchange.getResponseHeaders().set("Content-Type", "application/json; charset=UTF-8");
        sendResponse(exchange, code, json);
    }

    private void sendResponse(HttpExchange exchange, int code, String body) throws IOException {
        byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
        exchange.sendResponseHeaders(code, bytes.length);
        try (OutputStream os = exchange.getResponseBody()) {
            os.write(bytes);
        }
    }

    private String escape(String s) {
        if (s == null) return "";
        return s.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\n", "\\n")
                .replace("\r", "\\r");
    }
}