HospitalTree.java

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



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

/**
 *
 * @author egehanhatipoglu
 */


import java.util.ArrayList;


// Represents the organizational structure of the hospital using a General Tree (N-ary Tree).
// Unlike a Binary Tree, each node here can have an unlimited number of children (Departments).
public class HospitalTree {
    
   
    // INNER CLASS: DepartmentTreeNode
   
    // A node in the general tree. It contains the data (Department) 
    // and a list of children nodes (Sub-departments).
    private class DepartmentTreeNode {
        Department department;
        ArrayList<DepartmentTreeNode> children; 
        
        public DepartmentTreeNode(Department department) {
            this.department = department;
            this.children = new ArrayList<>();
        }
        
        public void addChild(DepartmentTreeNode child) {
            children.add(child);
        }
    }
    
    private DepartmentTreeNode root;
    
    // Constructor: Initializes the tree with the main "Hospital" entity as the Root Node.
    // All departments will be added as children to this root.
    public HospitalTree(String hospitalName) {
        Department hospital = new Department(0, hospitalName, 999);
        this.root = new DepartmentTreeNode(hospital);
    }
    
    // Adds a department to the tree. 
    // Currently, it adds departments directly under the root (Level 1 hierarchy).
    public void addDepartmentToRoot(Department department) {
        if (root != null && department != null) {
            DepartmentTreeNode newNode = new DepartmentTreeNode(department);
            root.addChild(newNode);
        }
    }
    
    
    // Initiates the display of the organizational chart.
    public void displayHierarchy() {
        System.out.println("");
        System.out.println("   HOSPITAL ORGANIZATION STRUCTURE         ");
        System.out.println("");
        displayHierarchyRec(root, 0);
    }
    
    // Recursive Traversal (DFS): Prints the tree structure.
    // Uses 'level' to calculate indentation, visually representing the parent-child relationships.
    // This is a Depth-First Search approach.
    private void displayHierarchyRec(DepartmentTreeNode node, int level) {
        String indent = "  ".repeat(level);
        String prefix = level == 0 ? " - " : " - ";
        
        System.out.println(indent + prefix + node.department.getName() + 
                         " (" + node.department.getDoctorCount() + " doctors)");
        
        for (DepartmentTreeNode child : node.children) {
            displayHierarchyRec(child, level + 1);
        }
    }
    
    public void showDepartmentDoctors(Department department) {
        System.out.println("\n=== " + department.getName() + " Department Doctors ===");
        
        if (department.getDoctors().isEmpty()) {
            System.out.println("  No doctors in this department.");
            return;
        }
        
        for (Doctor doctor : department.getDoctors()) {
            System.out.println("   Dr. " + doctor.getFirstName() + " " + 
                             doctor.getLastName() + " (Phone: " + doctor.getPhone() + ")");
        }
    }
    
   
    public int getDepartmentCount() {
        return countDepartments(root) - 1; // Root'u (hastaneyi) sayma
    }
    
    // Recursively counts the total number of nodes in the tree.
    private int countDepartments(DepartmentTreeNode node) {
        if (node == null) {
            return 0; }
        
        int count = 1;
        for (DepartmentTreeNode child : node.children) {
            count += countDepartments(child);
        }
        return count;
    }
    
    
    public int getTotalDoctorCount() {
        return countDoctors(root);
    }
    
    // Recursive Aggregation: Traverses the entire tree to sum up data (doctor counts)
    // from all nodes. Demonstrates how trees are useful for hierarchical data aggregation.
    private int countDoctors(DepartmentTreeNode node) {
        if (node == null)  {
            return 0;
        }
        
        int count = node.department.getDoctorCount();
        for (DepartmentTreeNode child : node.children) {
            count += countDoctors(child);
        }
        return count;
    }
    
}