HospitalManagementSystem.java

/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template
 */



/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template
 */
package hospitalmanagementsystem;

/**
 * Main Controller Class for the Hospital Management System.
 * This class orchestrates the interaction between all data structures (Hash Table, BST, AVL, Heap, Stack).
 * * @author egehanhatipoglu
 */

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Scanner;

public class HospitalManagementSystem {
    
  
    // CONFIGURATION & CONSTANTS
 
    // The Student ID is used to seed the system's capacity and constraints,
    // ensuring the project submission is unique.
    private static final int STUDENT_ID = 230316064;
    private final int MAX_PATIENT_NUMBER;
    private final int MAX_DOCTOR_NUMBER;

    
    // DATA STRUCTURES
    
    // Hash Tables: Used for O(1) instantaneous access to records by ID.
    private HashTable<Integer, Patient> patients;
    private HashTable<Integer, Doctor> doctors;
    private HashTable<Integer, Appointment> appointments;
    private HashTable<Integer, Department> departments;

    // Trees: Used for searching and hierarchical organization.
    private PatientBST patientBST;       // Standard Binary Search Tree for name search.
    private PatientAVL patientAVL;       // AVL Tree for balanced, optimized name search O(log n).
    private HospitalTree hospitalTree;   // General Tree for hospital department hierarchy.
    
    // queues & Stacks: Used for workflow management.
    private ERPriorityQueue erQueue;     // Priority Queue (Max-Heap) for Emergency Room Triage.
    private UndoStack undoStack;         // Stack (LIFO) for undoing administrative actions.

    private Scanner input = new Scanner(System.in);
    
    // ID Counters for auto-incrementing unique keys
    private int patientIdCounter = 0;
    private int doctorIdCounter = 0;
    private int appointmentIdCounter = 0;
    private int departmentIdCounter = 0;

    /**
     * Constructor: Initializes the system.
     * Sets dynamic capacities based on the Student ID modulo operations.
     */
    public HospitalManagementSystem() {
        
        // Dynamic capacity calculation ensures unique runtime behavior
        this.MAX_PATIENT_NUMBER = STUDENT_ID % 10 + 3;  
        this.MAX_DOCTOR_NUMBER = STUDENT_ID % 10 + 8;   

        // Initialize Hash Tables with custom capacity
        this.patients = new HashTable<>(STUDENT_ID);
        this.doctors = new HashTable<>(STUDENT_ID);
        this.appointments = new HashTable<>(STUDENT_ID);
        this.departments = new HashTable<>(STUDENT_ID);
        
        // Initialize other core data structures
        this.patientBST = new PatientBST();
        this.patientAVL = new PatientAVL();
        this.hospitalTree = new HospitalTree("Manisa Celal Bayar University Hospital");
        this.erQueue = new ERPriorityQueue();
        this.undoStack = new UndoStack();
    }

    public static void main(String[] args) {
        HospitalManagementSystem system = new HospitalManagementSystem();
        system.loadInitialSampleData(); // Pre-load data for testing
        system.menu(); // Start the main user interface loop
    }

    /**
     * Main Menu Loop.
     * Displays options and routes user input to specific handler methods.
     */
    void menu() {
        while (true) {
            
            System.out.println("");
            System.out.println(" HASTANE YÖNETİM SİSTEMİ           ");
            System.out.println(" ");
            System.out.println("1. Yeni Hasta Kaydet");
            System.out.println("2. Yeni Doktor Kaydet");
            System.out.println("3. Randevu Oluştur");
            System.out.println("4. Hastaları Listele (Hash Table)");
            System.out.println("5. Doktorları Listele");
            System.out.println("6. Randevuları Listele");
            System.out.println("7. Doktor Kuyruğunu Göster");
            System.out.println("8. Sıradaki Hastayı Muayene Et");
            System.out.println("9. Acil Servis İşlemleri");
            System.out.println("10. Hasta Tıbbi Geçmişi");
            System.out.println("11. Son İşlemi Geri Al (Undo)");
            System.out.println("12. İsme Göre Hasta Ara (BST)");
            System.out.println("13. Hastaları Alfabetik Listele (BST)");
            System.out.println("14. İsme Göre Hasta Ara (AVL - Dengeli)");
            System.out.println("15. Hastaları Alfabetik Listele (AVL)");
            System.out.println("16. AVL Ağacı İstatistikleri");
            System.out.println("17. Bölüm İşlemleri");
            System.out.println("18. Hastane Organizasyon Yapısı (Tree)");
            System.out.println("0. Çıkış");
            System.out.print("\nSeçiminiz: ");

            int secim;
            try {
                secim = input.nextInt();  
                input.nextLine(); // Consume newline
            } catch (Exception e) {
                input.nextLine();  
                System.out.println("✗ Geçersiz girdi! Lütfen bir sayı girin.");
                continue;  
            }
            
            try {
                switch (secim) {
                    case 1: registerNewPatient(); break;
                    case 2: registerNewDoctor(); break;
                    case 3: createAppointment(); break;
                    case 4: listPatients(); break;
                    case 5: listDoctors(); break;
                    case 6: listAppointments(); break;
                    case 7: showDoctorQueue(); break;
                    case 8: examinePatient(); break;
                    case 9: emergencyRoomMenu(); break;
                    case 10: showPatientHistory(); break;
                    case 11: undoLastOperation(); break;
                    case 12: searchPatientByName(); break;
                    case 13: patientBST.displayInOrder(); break;
                    case 14: searchPatientByNameAVL(); break;
                    case 15: patientAVL.displayInOrder(); break;
                    case 16: patientAVL.displayStats(); break;
                    case 17: departmentMenu(); break;
                    case 18: hospitalTree.displayHierarchy(); break;
                    case 0: return;
                    default: System.out.println(" Invalid choice!");
                }
            } catch (Exception e) {
                System.out.println(" Error: " + e.getMessage());
            }
        }
    }

    /**
     * Registers a new patient into the system.
     * Updates Hash Table, BST, and AVL Tree simultaneously to keep data synchronized.
     */
    void registerNewPatient() throws Exception {
        
        if (patients.size() >= MAX_PATIENT_NUMBER) {
            throw new Exception("Maximum patient capacity reached (" + MAX_PATIENT_NUMBER + ")!");
        }

        System.out.println("\n=== New Patient Registration ===");
        System.out.print("First Name: ");
        String firstName = input.nextLine();
        System.out.print("Last Name: ");
        String lastName = input.nextLine();
        
        // Check for duplicates using BST Search
        if (patientBST.search(firstName, lastName) != null) {
            
            System.out.println("✗ A patient with this name already exists!");
            return;
        }
        
        // Input Validation for National ID
        String nationalId = "";
        while (nationalId.length() != 11 || !nationalId.matches("\\d+")) {
            
            System.out.print("National ID (11 digits): ");
            nationalId = input.nextLine();
            
            if (nationalId.length() != 11) {
                System.out.println("✗ Must be 11 digits!");
            } else if (!nationalId.matches("\\d+")) {
                System.out.println("✗ Only numbers allowed!");
            }
        }
        
        System.out.print("Phone: ");
        String phone = input.nextLine();
        
        // Input Validation for Date
        LocalDate birthDate = null;
        while (birthDate == null) {
            
            try {
                
                System.out.print("Birth Date (yyyy-MM-dd): ");
                
                birthDate = LocalDate.parse(input.nextLine());
                if (birthDate.isAfter(LocalDate.now())) {
                    System.out.println("✗ Birth date cannot be in the future!");
                    birthDate = null;
                }
            } catch (Exception e) {
                System.out.println("✗ Invalid format! Use: yyyy-MM-dd (e.g., 1990-05-15)");
            }
        }

        int newId = ++patientIdCounter;
        
        Patient newPatient = new Patient(newId, firstName, lastName, nationalId, phone, birthDate);
        
        // Add to all data structures
        patients.put(newId, newPatient);
        patientBST.insert(newPatient);
        patientAVL.insert(newPatient);
        
        // Log operation for Undo
        undoStack.push("PATIENT_ADD:" + newId);

        System.out.println("✓ Patient successfully registered! ID: " + newId);
    }
    
    /**
     * Registers a new doctor and assigns them to a department.
     * Updates the Hospital Tree hierarchy.
     */
    void registerNewDoctor() throws Exception {
        
        
        if (doctors.size() >= MAX_DOCTOR_NUMBER) {
            throw new Exception("Maksimum doktor kapasitesine ulaşıldı (" + MAX_DOCTOR_NUMBER + ")!");
        }

        System.out.println("\n=== Yeni Doktor Kaydı ===");
        System.out.print("Ad: ");
        String firstName = input.nextLine();
        System.out.print("Soyad: ");
        String lastName = input.nextLine();
        
        listDepartments();
        System.out.print("\nBölüm ID (0 = Yeni bölüm oluştur): ");
        
        int deptId;
        try {
            
            deptId = input.nextInt();
            input.nextLine();
        } catch (Exception e) {
            input.nextLine();
            System.out.println("✗ Geçersiz bölüm ID!");
            return;
        }
        
        Department department;
        if (deptId == 0) {
            
            // Logic to create a new department on the fly
            System.out.print("Yeni Bölüm Adı: ");
            String deptName = input.nextLine();
            System.out.print("Kapasite: ");
            
            int capacity;
            try {
                
                capacity = input.nextInt();
                input.nextLine();
            } catch (Exception e) {
                
                input.nextLine();
                System.out.println("✗ Geçersiz kapasite değeri!");
                return;
            }
            
            if (capacity <= 0) {
                System.out.println("✗ Kapasite pozitif olmalı!");
                return;
            }
            
            department = new Department(++departmentIdCounter, deptName, capacity);
            departments.put(departmentIdCounter, department);
            
            hospitalTree.addDepartmentToRoot(department);
            System.out.println("✓ Yeni bölüm oluşturuldu!");
            
        } else {
            
            department = departments.get(deptId);
            if (department == null) {
                System.out.println("✗ Bölüm bulunamadı!");
                return;
            }
        }
        
        System.out.print("Telefon: ");
        String phone = input.nextLine();
        
        int newId = ++doctorIdCounter;
        Doctor newDoctor = new Doctor(newId, firstName, lastName, department, phone);
        
        // Try adding doctor to department (checks capacity)
        if (department.addDoctor(newDoctor)) {
            
            doctors.put(newId, newDoctor);
            undoStack.push("DOCTOR_ADD:" + newId);
            
            System.out.println("✓ Doktor kaydedildi! ID: " + newId);
            System.out.println("  Bölüm: " + department.getName());
            System.out.println("  Kalan kapasite: " + (department.getCapacity() - department.getDoctorCount()));
        } else {
            doctorIdCounter--;
            System.out.println("✗ Bölüm dolu!");
            System.out.println("  " + department.getName() + " bölümü kapasitesi: " + 
                             department.getDoctorCount() + "/" + department.getCapacity());
        }
    }
    
    
    // SEARCH METHODS
   

    void searchPatientByName() {
        
        System.out.println("\n Search Patient by Name (BST)");
        
        System.out.print("First Name: ");
        String firstName = input.nextLine();
        
        System.out.print("Last Name: ");
        String lastName = input.nextLine();

        Patient found = patientBST.search(firstName, lastName);
        if (found != null) {
            displayPatientInfo(found); 
        } else {
             System.out.println(" Patient not found!");
        }
    }

    void searchPatientByNameAVL() {
        
        System.out.println("\n Search Patient by Name (AVL) ");
        
        System.out.print("First Name: ");
        String firstName = input.nextLine();
        System.out.print("Last Name: ");
        String lastName = input.nextLine();

        Patient found = patientAVL.search(firstName, lastName);
        if (found != null) {  
            displayPatientInfo(found);
        } else {
            System.out.println(" Patient not found!");
        }
    }

    void displayPatientInfo(Patient patient) {
        System.out.println("  ID: " + patient.getId());
        System.out.println("  Name: " + patient.getFirstName() + " " + patient.getLastName());
    }

  
    // LISTING METHODS
  

    void listPatients() {
        if (patients.isEmpty()) {
            System.out.println("No registered patients.");
            return; 
        }
        for (Patient p : patients.values()) {
            System.out.println("ID: " + p.getId() + " | " + p.getFirstName() + " " + p.getLastName());
        }
    }

    void listDoctors() {
        for (Doctor d : doctors.values()) {
            System.out.println("ID: " + d.getId() + " | Dr. " + d.getFirstName() + " " + d.getLastName());
        }
    }

    void listDepartments() {
        for (Department d : departments.values()) {
            System.out.println(d);
        }
    }
    
    void listAppointments() {
        for(Appointment a : appointments.values()) {
            System.out.println(a); 
        }
    }

    void showPatientHistory() {
        System.out.print("\nPatient ID: ");
        int patientId = input.nextInt();
        input.nextLine();
        
        Patient patient = patients.get(patientId);
        if (patient != null){ 
            patient.printHistory(); 
        } else {
            System.out.println(" Patient not found!");
        }
    }

    
    // DEPARTMENT OPERATIONS
    

     void departmentMenu() {
        while (true) {  
            System.out.println("\n");
            System.out.println("     BÖLÜM İŞLEMLERİ                ");
            System.out.println(" ");
            System.out.println("1. Tüm Bölümleri Listele");
            System.out.println("2. Bölüm Doktorlarını Göster");
            System.out.println("3. Yeni Bölüm Oluştur");        
            System.out.println("4. Bölüm Detaylarını Göster");           
            System.out.println("5. Bölüm İstatistikleri");      
            System.out.println("0. Ana Menüye Dön");
            System.out.print("\nSeçiminiz: ");
            
            int choice;
            try {
                choice = input.nextInt();
                input.nextLine();
            } catch (Exception e) {
                input.nextLine();
                System.out.println("✗ Geçersiz seçim!");
                continue;
            }
            
            try {
                switch (choice) {
                    case 1: listDepartmentsDetails(); break;
                    case 2: showDepartmentDoctorsMenu(); break;
                    case 3: createNewDepartment(); break;
                    case 4: showDepartmentDetails(); break;
                    case 5: showDepartmentStatistics(); break;
                    case 0: return;
                    default: System.out.println("✗ Geçersiz seçim!"); 
                }
            } catch (Exception e) {
                System.out.println("✗ Hata: " + e.getMessage());
            }
        }
    }

   
    // APPOINTMENT & QUEUE OPERATIONS
 

    /**
     * Creates a new appointment with validation for time conflicts.
     * Enqueues the patient to the doctor's daily FIFO queue.
     */
    void createAppointment() {
        System.out.println("\n=== Yeni Randevu Oluştur ===");
        System.out.print("Hasta ID: ");
        
        int patientId;
        try {
            patientId = input.nextInt();
            input.nextLine();
        } catch (Exception e) {
            input.nextLine();
            System.out.println("✗ Geçersiz hasta ID!");
            return;
        }
        
        Patient patient = patients.get(patientId);
        if (patient == null) {
            System.out.println("✗ Hasta bulunamadı!");
            return;
        }
        
        listDoctors();
        System.out.print("Doktor ID: ");
        
        int doctorId;
        try {
            doctorId = input.nextInt();
            input.nextLine();
        } catch (Exception e) {
            input.nextLine();
            System.out.println("✗ Geçersiz doktor ID!");
            return;
        }
        
        Doctor doctor = doctors.get(doctorId);
        if (doctor == null) {
            System.out.println("✗ Doktor bulunamadı!");
            return;
        }
        
        System.out.print("Tarih (yyyy-MM-dd): ");
        String date = input.nextLine();
        System.out.print("Saat (HH:mm): ");
        String time = input.nextLine();
        
        LocalDateTime appointmentTime;
        try {
            appointmentTime = LocalDateTime.parse(date + "T" + time);
        } catch (Exception e) {
            System.out.println("✗ Hata: Geçersiz tarih/saat formatı!");
            return;
        }
        
        // --- CONFLICT CHECKS ---
        if (isAppointmentInPast(appointmentTime)) {
            System.out.println("✗ Hata: Geçmiş tarihe randevu oluşturulamaz!");
            return;
        }
        
        if (doctorHasAppointmentAtTime(doctor, appointmentTime)) {
            System.out.println("✗ Hata: Doktor bu saatte müsait değil!");
            return;
        }
        
        if (patientHasAppointmentAtTime(patient, appointmentTime)) {
            System.out.println("✗ Hata: Hastanın bu saatte zaten randevusu var!");
            return;
        }
        
        // All checks passed - Create Appointment
        try {
            Appointment appointment = new Appointment(
                ++appointmentIdCounter, 
                patient, 
                doctor, 
                appointmentTime
            );
            appointments.put(appointmentIdCounter, appointment);
            
            doctor.getDailyQueue().enqueue(appointment); // Add to FIFO queue
            
            undoStack.push("APPOINTMENT_ADD:" + appointmentIdCounter);
            
            System.out.println("\n✓ Randevu başarıyla oluşturuldu!");
            System.out.println("  Randevu ID: " + appointmentIdCounter);
            
        } catch (Exception e) {
            System.out.println("✗ Beklenmeyen hata: " + e.getMessage());
            appointmentIdCounter--;
        }
    }

    void showDoctorQueue() {
        System.out.print("Doctor ID: ");
        Doctor doctor = doctors.get(input.nextInt());
        if(doctor!=null) {
            doctor.getDailyQueue().display(); 
        }
    }

    /**
     * Simulates the doctor examining the next patient in the queue.
     * Dequeues the appointment and adds a visit record to the patient's history.
     */
    void examinePatient() {
        System.out.print("Doktor ID: ");
        int doctorId = input.nextInt();
        input.nextLine();
        
        Doctor doctor = doctors.get(doctorId);
        if (doctor == null) {
            System.out.println("✗ Doktor bulunamadı!");
            return;
        }
        
        // Remove patient from the front of the queue (FIFO)
        Appointment appointment = doctor.getDailyQueue().dequeue();
        if (appointment == null) {
            System.out.println("✗ Kuyruk boş - muayene edilecek hasta yok.");
            return;
        }
        
        System.out.println("\n=== Muayene Ediliyor ===");
        System.out.println("Hasta: " + appointment.getPatient().getFirstName() + " " + 
                           appointment.getPatient().getLastName());
        
        System.out.print("Muayene Notları: ");
        String notes = input.nextLine();
        
        // Add to medical history linked list
        appointment.getPatient().addVisit(
            LocalDateTime.now(), 
            doctor,
            notes
        );
        
        appointment.setStatus("Completed");
        System.out.println("\n✓ Muayene tamamlandı!");
    }

    private int getQueueSize(AppointmentQueue queue) {
        return queue.size();
    }
    
   
    // EMERGENCY ROOM (TRIAGE) OPERATIONS
   

    void emergencyRoomMenu() {
       System.out.println("\n=== Acil Servis İşlemleri ===");
        System.out.println("1. Yeni Hasta Kabul Et");
        System.out.println("2. En Acil Hastayı Tedavi Et");
        System.out.println("3. Acil Servis Kuyruğunu Göster");
        System.out.println("4. Acil Servisten Hasta Sil");
        System.out.println("0. Ana Menüye Dön");
        System.out.print("\nSeçiminiz: ");
        
        int choice;
        try {
            choice = input.nextInt();
            input.nextLine();
        } catch (Exception e) {
            input.nextLine();
            System.out.println("✗ Geçersiz seçim!");
            return;
        }
        
        if (choice == 1) {
            // Add Patient to ER
            System.out.print("Hasta ID: ");
            int patientId = input.nextInt();
            input.nextLine();
            
            Patient patient = patients.get(patientId);
            if (patient == null) {
                System.out.println("✗ Hasta bulunamadı!");
                return;
            }
            
            System.out.print("Önem Derecesi (1-10, 10=en acil): ");
            int severity = input.nextInt();
            input.nextLine();
            
            if (severity < 1 || severity > 10) {
                System.out.println("✗ Önem derecesi 1-10 arasında olmalı!");
                return;
            }
            
            System.out.print("Şikayet/Semptomlar: ");
            String complaint = input.nextLine().trim();
            
            // Add to Priority Queue (Max-Heap)
            ERPriorityQueue.ERPatient erPatient = 
                new ERPriorityQueue.ERPatient(patient, severity, complaint);
            erQueue.addPatient(erPatient);
            
            undoStack.push("ER_ADD", erPatient);
            
            System.out.println("\n✓ Hasta acil servise kabul edildi!");
            
        } else if (choice == 2) {
            // Treat Highest Priority Patient
            ERPriorityQueue.ERPatient erPatient = erQueue.removeHighestPriority();
            
            if (erPatient == null) {
                System.out.println("✗ Acil serviste hasta yok.");
                return;
            }
            
            System.out.println("\n=== Tedavi Ediliyor ===");
            System.out.println("Hasta: " + erPatient.getPatient().getFirstName());
            System.out.println("Önem: " + erPatient.getSeverity() + "/10");
            
            // ... (Treatment logic and logging visit) ...
            
            System.out.println("✓ Tedavi tamamlandı!");
            
        } else if (choice == 3) {
            erQueue.display();
        } else if (choice == 4) {
            deleteERPatient();
        } else if (choice == 0) {
            return;
        } else {
            System.out.println("✗ Geçersiz seçim!");
        }
    }

    void deleteERPatient() {
        if (erQueue.isEmpty()) {
            System.out.println("✗ Acil servis kuyruğu boş!");
            return;
        }
        
        erQueue.display();
        System.out.print("\nSilinecek Hasta ID'si: ");
        int patientId = input.nextInt();
        input.nextLine();
        
        boolean removed = erQueue.removePatientById(patientId);
        
        if (removed) {
            System.out.println("\n✓ Hasta acil servis kuyruğundan silindi!");
        } else {
            System.out.println("\n✗ Bu ID'ye sahip hasta bulunamadı!");
        }
    }
    
    // ============================================
    // UNDO OPERATIONS
    // ============================================

    /**
     * Reverts the last "Add" operation performed.
     * Uses a Stack (LIFO) to track history.
     */
    void undoLastOperation() {
        if (undoStack.isEmpty()) { 
            System.out.println("Geri alınacak işlem yok."); 
            return; 
        }
        
        // Pop last operation from Stack
        UndoStack.StackNode node = undoStack.popWithData();
        String op = node.operation;
        String[] parts = op.split(":");
        
        // UNDO PATIENT ADD
        if (parts[0].equals("PATIENT_ADD")) {
            int patientId = Integer.parseInt(parts[1]);
            Patient patient = patients.get(patientId);
            
            if (patient == null) return;
            
            // Remove associated appointments first
            ArrayList<Integer> appointmentIdsToRemove = new ArrayList<>();
            for (Appointment app : appointments.values()) {
                if (app.getPatient().getId() == patientId) {
                    appointmentIdsToRemove.add(app.getId());
                }
            }
            
            for (int appId : appointmentIdsToRemove) {
                Appointment app = appointments.get(appId);
                if (app != null) {
                    removeAppointmentFromQueue(app.getDoctor().getDailyQueue(), appId);
                    appointments.remove(appId);
                }
            }
            
            // Remove patient from all data structures
            patients.remove(patientId);
            patientBST.delete(patient.getFirstName(), patient.getLastName());
            patientAVL.delete(patient.getFirstName(), patient.getLastName());
            
            if (patientId == patientIdCounter) patientIdCounter--;
            
            System.out.println("✓ Geri alma: Hasta ve randevuları silindi.");
        }
        
        // UNDO DOCTOR ADD
        else if (parts[0].equals("DOCTOR_ADD")) {
            int doctorId = Integer.parseInt(parts[1]);
            Doctor doctor = doctors.get(doctorId);
            
            if (doctor == null) return;
            
            // Clean up doctor's queue and appointments
            while (!doctor.getDailyQueue().isEmpty()) {
                doctor.getDailyQueue().dequeue();
            }
            
            doctor.getDepartment().getDoctors().remove(doctor);
            doctors.remove(doctorId);
            
            if (doctorId == doctorIdCounter) doctorIdCounter--;
            
            System.out.println("✓ Geri alma: Doktor silindi.");
        }
        
        // UNDO APPOINTMENT ADD
        else if (parts[0].equals("APPOINTMENT_ADD")) {
            int appointmentId = Integer.parseInt(parts[1]);
            Appointment appointment = appointments.get(appointmentId);
            
            if (appointment == null) return;
            
            Doctor doctor = appointment.getDoctor();
            removeAppointmentFromQueue(doctor.getDailyQueue(), appointmentId);
            appointments.remove(appointmentId);
            
            if (appointmentId == appointmentIdCounter) appointmentIdCounter--;
            
            System.out.println("✓ Geri alma: Randevu silindi.");
        }
        
        // UNDO ER ADD
        else if (parts[0].equals("ER_ADD")) {
            Object data = node.data;
            if (data instanceof ERPriorityQueue.ERPatient) {
                ERPriorityQueue.ERPatient erPatient = (ERPriorityQueue.ERPatient) data;
                boolean removed = erQueue.removePatientById(erPatient.getPatient().getId());
                
                if (removed) System.out.println("✓ Geri alma: Acil servis hastası silindi.");
            }
        }
    }

    // Helper: Removes a specific appointment from a doctor's queue without breaking FIFO order.
    private void removeAppointmentFromQueue(AppointmentQueue queue, int appointmentId) {
        if (queue.isEmpty()) return;
        
        AppointmentQueue tempQueue = new AppointmentQueue();
        boolean found = false;
        
        while (!queue.isEmpty()) {
            Appointment current = queue.dequeue();
            if (current.getId() != appointmentId) {
                tempQueue.enqueue(current);
            } else {
                found = true;
            }
        }
        
        while (!tempQueue.isEmpty()) {
            queue.enqueue(tempQueue.dequeue());
        }
    }
    
   
    // INITIALIZATION & UTILS
   

    void loadInitialSampleData() {
        
        System.out.println("Hash Table Capacity based on Student ID: " + ((STUDENT_ID % 100) + 50));
        System.out.println("\n=== Loading Sample Data ===");
        System.out.println("Student ID: " + STUDENT_ID);
        
        System.out.println("Appointment Duration: " + (15 + (STUDENT_ID % 5)) + " minutes");

        // Create departments
        Department cardiology = new Department(++departmentIdCounter, "Cardiology", 5);
        departments.put(departmentIdCounter, cardiology);
        hospitalTree.addDepartmentToRoot(cardiology);

        Department neurology = new Department(++departmentIdCounter, "Neurology", 4);
        departments.put(departmentIdCounter, neurology);
        hospitalTree.addDepartmentToRoot(neurology);
        
        Department emergency = new Department(++departmentIdCounter, "Emergency Medicine", 8);
        departments.put(departmentIdCounter, emergency);
        hospitalTree.addDepartmentToRoot(emergency);

        // Create Doctors
        Doctor d1 = new Doctor(++doctorIdCounter, "Mehmet", "Yilmaz", cardiology, "0532-111-2233");
        cardiology.addDoctor(d1);
        doctors.put(doctorIdCounter, d1);

        Doctor d4 = new Doctor(++doctorIdCounter, "Semih", "Arslan", emergency, "0535-444-5566");
        emergency.addDoctor(d4);
        doctors.put(doctorIdCounter, d4);

        // Create Patients
        Patient p1 = new Patient(++patientIdCounter, "Ahmet", "Oz", "12345678901", "0535-444-5566", LocalDate.of(1985, 5, 15));
        patients.put(patientIdCounter, p1);
        patientBST.insert(p1);
        patientAVL.insert(p1);

        // Add history
        p1.addVisit(LocalDateTime.of(2024, 10, 15, 10, 30), d1, "Annual checkup");

        System.out.println("\n✓ Sample data loaded successfully!");
    }

    // Helper methods for displaying detailed department info
    void listDepartmentsDetails() {
        
        if (departments.isEmpty()) {
            System.out.println("No departments yet.");
            return;
        }
        System.out.println("\n=== All Departments ===");
        for (Department department : departments.values()) {
            
            int remaining = department.getCapacity() - department.getDoctorCount();
            System.out.println("ID: " + department.getId() +
                             " | " + department.getName() +
                             " | Doctors: " + department.getDoctorCount() + "/" + department.getCapacity() +
                             " | Remaining capacity: " + remaining);
        }
    }

    void showDepartmentDoctorsMenu(){
        
        if(departments.isEmpty()) return;
        listDepartments();
        System.out.print("\nDepartment ID: ");
         try {
              int departmentId=input.nextInt();
              Department department=departments.get(departmentId);
              if(department!=null) {
                   hospitalTree.showDepartmentDoctors(department);
              } else {
                System.out.println("Department not found!");
              }
         } catch(Exception e){
            System.out.println("error invalid choice");
        }
     }

    void showDepartmentStatistics(){
         if (departments.isEmpty()) return;
         System.out.println("\n=== Department Statistics ===");
         
         int totalCapacity = 0;
         
         int totalDoctors = 0;
         for (Department d : departments.values()) {
             
            totalCapacity += d.getCapacity();
            totalDoctors += d.getDoctorCount();
         }
         System.out.println("Total Departments: " + departments.size());
         System.out.println("Total Capacity: " + totalCapacity);
         System.out.println("Total Doctors: " + totalDoctors);
    }
    
    void showDepartmentDetails() {
        
        if (departments.isEmpty()) { 
            return;
        }
        listDepartments();
        System.out.print("Department ID: ");
        
        try {
            int deptId = input.nextInt();
            input.nextLine();
            Department dept = departments.get(deptId);
            if (dept == null)  {
                return;
            }
            
            System.out.println("=== Department Details ===");
            System.out.println("ID: " + dept.getId());
            System.out.println("Name: " + dept.getName());
            if (!dept.getDoctors().isEmpty()) {
                System.out.println("\nDoctors:");
                for (Doctor doc : dept.getDoctors()) {
                    System.out.println(" - Dr. " + doc.getFirstName() + " " + doc.getLastName());
                }
            }
        } catch (Exception e) {
            input.nextLine();
        }
    }
    
    void createNewDepartment() {
        
        System.out.println("=== Create New Department ===");
        System.out.print("Department Name: ");
        String name = input.nextLine().trim();
        
        System.out.print("Capacity: ");
        try {
            
            int capacity = input.nextInt();
            
            input.nextLine();
            if (capacity <= 0) return;
            
            Department newDept = new Department(++departmentIdCounter, name, capacity);
            departments.put(departmentIdCounter, newDept);
            hospitalTree.addDepartmentToRoot(newDept);
            System.out.println("Department created! ID: " + departmentIdCounter);
            
        } catch (Exception e) {
            input.nextLine();
        }
    }

   
    // UTILITY: CONFLICT CHECKING
  

    private boolean appointmentsOverlap(LocalDateTime start1, LocalDateTime end1, LocalDateTime start2, LocalDateTime end2) {
        return start1.isBefore(end2) && start2.isBefore(end1);
    }

    private boolean doctorHasAppointmentAtTime(Doctor doctor, LocalDateTime appointmentTime) {
        
        LocalDateTime newEnd = appointmentTime.plusMinutes(15);
        
        for (Appointment app : appointments.values()) {
            if (app.getDoctor().getId() == doctor.getId()) {
                
                if (appointmentsOverlap(appointmentTime, newEnd, app.getStart(), app.getEnd())) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean patientHasAppointmentAtTime(Patient patient, LocalDateTime appointmentTime) {
        
        LocalDateTime newEnd = appointmentTime.plusMinutes(15);
        
        for (Appointment app : appointments.values()) {
            
            if (app.getPatient().getId() == patient.getId()) {
                
                if (appointmentsOverlap(appointmentTime, newEnd, app.getStart(), app.getEnd())) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean isAppointmentInPast(LocalDateTime appointmentTime) {
        return appointmentTime.isBefore(LocalDateTime.now());
    }
    
}