Bagian 1: Desain API

/** Status pengerjaan sebuah tugas. */
public enum StatusTugas {
    TODO,
    SELESAI;

    /**
     * Mengubah teks JSON menjadi status.
     * Melempar IllegalArgumentException dengan pesan jelas bila teks tidak dikenal.
     */
    public static StatusTugas dariTeks(String teks) {
        for (StatusTugas s : values()) {
            if (s.name().equals(teks)) {
                return s;
            }
        }
        throw new IllegalArgumentException(
                "status '" + teks + "' tidak dikenal, gunakan TODO atau SELESAI");
    }
}

import java.time.LocalDate;

/**
 * Representasi satu tugas sebagai resource API.
 * Invarian dasar dijaga compact constructor sehingga objek Tugas tidak pernah
 * berada dalam keadaan tidak sah, apa pun asal datanya (kode atau payload klien).
 */
public record Tugas(int id, String judul, String pemilik, StatusTugas status, LocalDate tenggat) {

    public Tugas {
        if (judul == null || judul.strip().isEmpty()) {
            throw new IllegalArgumentException("judul tidak boleh kosong");
        }
        if (pemilik == null || pemilik.strip().isEmpty()) {
            throw new IllegalArgumentException("pemilik tidak boleh kosong");
        }
        if (tenggat == null) {
            throw new IllegalArgumentException("tenggat tidak boleh kosong");
        }
        judul = judul.strip();
        pemilik = pemilik.strip();
    }
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Serializer dan parser JSON mini untuk kebutuhan proyek ini:
 * objek datar dengan nilai berupa teks, angka, boolean, atau null.
 * Pustaka JSON umum (Jackson, Gson) menangani kasus jauh lebih banyak;
 * versi mini ini cukup untuk payload dan respons API tugas sekaligus
 * memperlihatkan cara kerja escaping dan parsing secara langsung.
 */
public final class JsonMini {

    private JsonMini() {
        // Kelas utilitas: seluruh anggota static, tidak perlu instance.
    }

    /** Meng-escape karakter yang wajib diloloskan di dalam string JSON. */
    public static String escape(String teks) {
        StringBuilder hasil = new StringBuilder();
        for (int i = 0; i < teks.length(); i++) {
            char c = teks.charAt(i);
            switch (c) {
                case '"' -> hasil.append("\\\"");
                case '\\' -> hasil.append("\\\\");
                case '\n' -> hasil.append("\\n");
                case '\t' -> hasil.append("\\t");
                case '\r' -> hasil.append("\\r");
                default -> {
                    if (c < 0x20) {
                        hasil.append(String.format("\\u%04x", (int) c));
                    } else {
                        hasil.append(c);
                    }
                }
            }
        }
        return hasil.toString();
    }

    /** Membungkus teks menjadi string JSON yang sah (dengan kutip dan escape). */
    public static String string(String teks) {
        return "\"" + escape(teks) + "\"";
    }

    /** Mengubah satu Tugas menjadi objek JSON dengan field yang urutannya tetap. */
    public static String tugas(Tugas t) {
        return "{\"id\":" + t.id()
                + ",\"judul\":" + string(t.judul())
                + ",\"pemilik\":" + string(t.pemilik())
                + ",\"status\":\"" + t.status() + "\""
                + ",\"tenggat\":\"" + t.tenggat() + "\"}";
    }

    /** Mengubah daftar Tugas menjadi array JSON. */
    public static String daftar(List<Tugas> semua) {
        return semua.stream()
                .map(JsonMini::tugas)
                .collect(Collectors.joining(",", "[", "]"));
    }

    /** Amplop pesan error yang seragam untuk seluruh respons gagal. */
    public static String error(String pesan) {
        return "{\"error\":" + string(pesan) + "}";
    }

    /**
     * Mem-parsing objek JSON datar menjadi Map; urutan field dipertahankan.
     * Nilai berupa String, Long, Double, Boolean, atau null.
     * Melempar IllegalArgumentException berbahasa Indonesia bila JSON tidak sah.
     */
    public static Map<String, Object> parseObjek(String json) {
        Pembaca baca = new Pembaca(json);
        Map<String, Object> hasil = baca.objek();
        baca.spasi();
        if (!baca.habis()) {
            throw baca.galat("konten tambahan setelah objek");
        }
        return hasil;
    }

    /** Pembaca JSON karakter demi karakter dengan posisi yang terlacak. */
    private static final class Pembaca {

        private final String teks;
        private int pos = 0;

        Pembaca(String teks) {
            this.teks = teks;
        }

        /** Membaca '{' sampai '}' menjadi LinkedHashMap. */
        Map<String, Object> objek() {
            spasi();
            harap('{');
            Map<String, Object> hasil = new LinkedHashMap<>();
            spasi();
            if (lihat() == '}') {
                pos++;
                return hasil;
            }
            while (true) {
                spasi();
                String kunci = string();
                spasi();
                harap(':');
                spasi();
                hasil.put(kunci, nilai());
                spasi();
                if (lihat() == ',') {
                    pos++;
                    continue;
                }
                harap('}');
                return hasil;
            }
        }

        /** Satu nilai: string, true, false, null, atau angka. */
        Object nilai() {
            char c = lihat();
            if (c == '"') {
                return string();
            }
            if (c == 't') {
                harapKata("true");
                return Boolean.TRUE;
            }
            if (c == 'f') {
                harapKata("false");
                return Boolean.FALSE;
            }
            if (c == 'n') {
                harapKata("null");
                return null;
            }
            return angka();
        }

        /** Membaca string berikut kutip pembuka dan penutupnya. */
        String string() {
            harap('"');
            StringBuilder hasil = new StringBuilder();
            while (pos < teks.length()) {
                char c = teks.charAt(pos++);
                if (c == '"') {
                    return hasil.toString();
                }
                if (c == '\\') {
                    hasil.append(escapeBerikutnya());
                } else {
                    hasil.append(c);
                }
            }
            throw galat("string tidak ditutup kutip");
        }

        /** Membaca satu karakter hasil escape, misalnya \n atau \". */
        char escapeBerikutnya() {
            if (pos >= teks.length()) {
                throw galat("escape berada di ujung string");
            }
            char c = teks.charAt(pos++);
            return switch (c) {
                case '"' -> '"';
                case '\\' -> '\\';
                case '/' -> '/';
                case 'n' -> '\n';
                case 't' -> '\t';
                case 'r' -> '\r';
                case 'b' -> '\b';
                case 'f' -> '\f';
                default -> throw galat("escape tidak dikenal: \\" + c);
            };
        }

        /** Membaca angka bulat atau pecahan tanpa notasi ilmiah. */
        Object angka() {
            int awal = pos;
            if (lihat() == '-') {
                pos++;
            }
            while (pos < teks.length() && "0123456789.".indexOf(teks.charAt(pos)) >= 0) {
                pos++;
            }
            String teksAngka = teks.substring(awal, pos);
            if (teksAngka.isEmpty() || teksAngka.equals("-")) {
                throw galat("nilai tidak dikenal mulai di posisi " + awal);
            }
            try {
                if (teksAngka.indexOf('.') >= 0) {
                    return Double.valueOf(teksAngka);
                }
                return Long.valueOf(teksAngka);
            } catch (NumberFormatException e) {
                throw galat("angka tidak sah: " + teksAngka);
            }
        }

        /** Memastikan kata kunci (true/false/null) ada di posisi sekarang. */
        void harapKata(String kata) {
            if (!teks.startsWith(kata, pos)) {
                throw galat("kata kunci '" + kata + "' tidak ditemukan");
            }
            pos += kata.length();
        }

        /** Melewati spasi dan whitespace lain. */
        void spasi() {
            while (pos < teks.length() && Character.isWhitespace(teks.charAt(pos))) {
                pos++;
            }
        }

        /** Melihat karakter pada posisi sekarang tanpa memajukannya. */
        char lihat() {
            if (pos >= teks.length()) {
                throw galat("teks berakhir sebelum waktunya");
            }
            return teks.charAt(pos);
        }

        /** Memastikan karakter yang diharapkan ada, lalu memajukan posisi. */
        void harap(char diharapkan) {
            char c = lihat();
            if (c != diharapkan) {
                throw galat("diharapkan '" + diharapkan + "', ditemukan '" + c + "'");
            }
            pos++;
        }

        boolean habis() {
            return pos >= teks.length();
        }

        IllegalArgumentException galat(String pesan) {
            return new IllegalArgumentException(pesan + " (posisi " + pos + ")");
        }
    }
}

import java.time.LocalDate;
import java.util.Map;

/** Bagian 1: memperagakan format pesan JSON untuk resource tugas. */
public class DemoPesan {

    public static void main(String[] args) {
        Tugas tugas = new Tugas(1, "Belajar desain REST API", "Budi",
                StatusTugas.TODO, LocalDate.of(2026, 1, 20));

        // Respons untuk GET /api/tugas/1
        System.out.println("Respons GET /api/tugas/1 (200):");
        System.out.println(JsonMini.tugas(tugas));

        // Payload yang dikirim klien pada POST /api/tugas
        String permintaan = "{\"judul\":\"Tulis dokumentasi API\","
                + "\"pemilik\":\"Siti\",\"tenggat\":\"2026-02-01\"}";
        Map<String, Object> payload = JsonMini.parseObjek(permintaan);
        System.out.println();
        System.out.println("Payload POST /api/tugas setelah diparsing:");
        System.out.println("judul   = " + payload.get("judul"));
        System.out.println("pemilik = " + payload.get("pemilik"));
        System.out.println("tenggat = " + payload.get("tenggat"));

        // Server menyimpan payload, lalu menjawab dengan tugas yang sudah ber-id
        Tugas baru = new Tugas(2, (String) payload.get("judul"), (String) payload.get("pemilik"),
                StatusTugas.TODO, LocalDate.parse((String) payload.get("tenggat")));
        System.out.println();
        System.out.println("Respons POST /api/tugas (201):");
        System.out.println(JsonMini.tugas(baru));

        // Amplop error yang sama untuk semua respons gagal
        System.out.println();
        System.out.println("Respons GET /api/tugas/9 (404):");
        System.out.println(JsonMini.error("tugas dengan id 9 tidak ditemukan"));

        // Parser juga mengenali angka, boolean, null, dan angka pecahan
        Map<String, Object> campuran = JsonMini.parseObjek(
                "{\"versi\":2,\"stabil\":true,\"catatan\":null,\"skor\":4.5}");
        System.out.println();
        System.out.println("Parser nilai campuran : " + campuran);

        // Judul yang memuat kutip ganda dan backslash wajib di-escape
        String judulAneh = "Belajar \"escape\" di \\ JSON";
        System.out.println("Judul di-escape       : " + JsonMini.string(judulAneh));
    }
}

Respons GET /api/tugas/1 (200):
{"id":1,"judul":"Belajar desain REST API","pemilik":"Budi","status":"TODO","tenggat":"2026-01-20"}

Payload POST /api/tugas setelah diparsing:
judul   = Tulis dokumentasi API
pemilik = Siti
tenggat = 2026-02-01

Respons POST /api/tugas (201):
{"id":2,"judul":"Tulis dokumentasi API","pemilik":"Siti","status":"TODO","tenggat":"2026-02-01"}

Respons GET /api/tugas/9 (404):
{"error":"tugas dengan id 9 tidak ditemukan"}

Parser nilai campuran : {versi=2, stabil=true, catatan=null, skor=4.5}
Judul di-escape       : "Belajar \"escape\" di \\ JSON"