LibraryManagement.java

import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class LibraryManagement extends JFrame {
    // Color scheme
    private static final Color PRIMARY_COLOR = new Color(41, 128, 185);
    private static final Color SECONDARY_COLOR = new Color(52, 73, 94);
    private static final Color SUCCESS_COLOR = new Color(46, 204, 113);
    private static final Color DANGER_COLOR = new Color(231, 76, 60);
    private static final Color BG_COLOR = new Color(236, 240, 241);
    
    private JTextField tfBookId, tfTitle, tfAuthor, tfPublisher, tfYear, tfIsbn, tfCopies, tfSearch;
    private JButton btnAdd, btnEdit, btnDelete, btnClear, btnSearch;
    private ArrayList<String[]> books = new ArrayList<>();
    private JTable table;
    private DefaultTableModel tableModel;
    private JLabel statusLabel;
    private JTabbedPane tabbedPane;

    public LibraryManagement() {
        setTitle("Library Management System");
        setSize(1300, 750);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        getContentPane().setBackground(BG_COLOR);
        
        // Create tabbed pane
        tabbedPane = new JTabbedPane();
        tabbedPane.setFont(new Font("Segoe UI", Font.BOLD, 16));
        
        // Add tabs
        tabbedPane.addTab("📚 Manage Books", createManagePanel());
        tabbedPane.addTab("📋 View All Books", createViewPanel());
        
        add(tabbedPane, BorderLayout.CENTER);
        add(createStatusBar(), BorderLayout.SOUTH);
        
        setVisible(true);
    }

    private JPanel createManagePanel() {
        JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
        mainPanel.setBackground(BG_COLOR);
        mainPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        
        // Title
        JLabel titleLabel = new JLabel("Book Information", SwingConstants.CENTER);
        titleLabel.setFont(new Font("Segoe UI", Font.BOLD, 28));
        titleLabel.setForeground(SECONDARY_COLOR);
        mainPanel.add(titleLabel, BorderLayout.NORTH);
        
        // Form panel
        JPanel formPanel = new JPanel(new GridBagLayout());
        formPanel.setBackground(Color.WHITE);
        formPanel.setBorder(BorderFactory.createCompoundBorder(
            BorderFactory.createLineBorder(new Color(189, 195, 199), 2, true),
            BorderFactory.createEmptyBorder(30, 30, 30, 30)
        ));
        
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.fill = GridBagConstraints.HORIZONTAL;
        gbc.insets = new Insets(8, 8, 8, 8);
        
        Font labelFont = new Font("Segoe UI", Font.BOLD, 16);
        Font fieldFont = new Font("Segoe UI", Font.PLAIN, 16);
        
        // Create fields
        tfBookId = createStyledTextField(fieldFont);
        tfTitle = createStyledTextField(fieldFont);
        tfAuthor = createStyledTextField(fieldFont);
        tfPublisher = createStyledTextField(fieldFont);
        tfYear = createStyledTextField(fieldFont);
        tfIsbn = createStyledTextField(fieldFont);
        tfCopies = createStyledTextField(fieldFont);
        
        // Add components
        addFormRow(formPanel, "Book ID:", tfBookId, gbc, 0, labelFont);
        addFormRow(formPanel, "Book Title:", tfTitle, gbc, 1, labelFont);
        addFormRow(formPanel, "Author:", tfAuthor, gbc, 2, labelFont);
        addFormRow(formPanel, "Publisher:", tfPublisher, gbc, 3, labelFont);
        addFormRow(formPanel, "Year:", tfYear, gbc, 4, labelFont);
        addFormRow(formPanel, "ISBN:", tfIsbn, gbc, 5, labelFont);
        addFormRow(formPanel, "Copies:", tfCopies, gbc, 6, labelFont);
        
        mainPanel.add(formPanel, BorderLayout.CENTER);
        
        // Button panel
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 15, 15));
        buttonPanel.setBackground(BG_COLOR);
        
        btnAdd = createStyledButton("➕ Add", SUCCESS_COLOR);
        btnEdit = createStyledButton("✏️ Edit", PRIMARY_COLOR);
        btnDelete = createStyledButton("🗑️ Delete", DANGER_COLOR);
        btnClear = createStyledButton("🔄 Clear", SECONDARY_COLOR);
        
        btnAdd.addActionListener(e -> addBook());
        btnEdit.addActionListener(e -> editBook());
        btnDelete.addActionListener(e -> deleteBook());
        btnClear.addActionListener(e -> clearFields());
        
        buttonPanel.add(btnAdd);
        buttonPanel.add(btnEdit);
        buttonPanel.add(btnDelete);
        buttonPanel.add(btnClear);
        
        mainPanel.add(buttonPanel, BorderLayout.SOUTH);
        
        return mainPanel;
    }

    private JPanel createViewPanel() {
        JPanel panel = new JPanel(new BorderLayout(10, 10));
        panel.setBackground(BG_COLOR);
        panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        
        // Search panel
        JPanel searchPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 10));
        searchPanel.setBackground(BG_COLOR);
        
        JLabel searchLabel = new JLabel("🔍 Search:");
        searchLabel.setFont(new Font("Segoe UI", Font.BOLD, 16));
        tfSearch = createStyledTextField(new Font("Segoe UI", Font.PLAIN, 16));
        tfSearch.setPreferredSize(new Dimension(300, 35));
        
        btnSearch = createStyledButton("Search", PRIMARY_COLOR);
        btnSearch.addActionListener(e -> searchBooks());
        
        JButton btnShowAll = createStyledButton("Show All", SECONDARY_COLOR);
        btnShowAll.addActionListener(e -> refreshTable());
        
        searchPanel.add(searchLabel);
        searchPanel.add(tfSearch);
        searchPanel.add(btnSearch);
        searchPanel.add(btnShowAll);
        
        panel.add(searchPanel, BorderLayout.NORTH);
        
        // Table
        String[] columns = {"Book ID", "Title", "Author", "Publisher", "Year", "ISBN", "Copies"};
        tableModel = new DefaultTableModel(columns, 0) {
            @Override
            public boolean isCellEditable(int row, int column) {
                return false;
            }
        };
        
        table = new JTable(tableModel);
        table.setFont(new Font("Segoe UI", Font.PLAIN, 15));
        table.setRowHeight(40);
        table.setGridColor(new Color(189, 195, 199));
        table.setSelectionBackground(new Color(52, 152, 219));
        table.setSelectionForeground(Color.WHITE);
        table.setShowGrid(true);
        table.setIntercellSpacing(new Dimension(1, 1));
        
        // Center align some columns
        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
        centerRenderer.setHorizontalAlignment(JLabel.CENTER);
        table.getColumnModel().getColumn(0).setCellRenderer(centerRenderer); // Book ID
        table.getColumnModel().getColumn(4).setCellRenderer(centerRenderer); // Year
        table.getColumnModel().getColumn(6).setCellRenderer(centerRenderer); // Copies
        
        // Header styling
        JTableHeader header = table.getTableHeader();
        header.setFont(new Font("Segoe UI", Font.BOLD, 16));
        header.setBackground(SECONDARY_COLOR);
        header.setForeground(Color.WHITE);
        header.setPreferredSize(new Dimension(header.getPreferredSize().width, 45));
        header.setReorderingAllowed(false);
        
        // Custom renderer for header to ensure text is visible
        DefaultTableCellRenderer headerRenderer = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value,
                    boolean isSelected, boolean hasFocus, int row, int column) {
                JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, 
                        isSelected, hasFocus, row, column);
                label.setBackground(SECONDARY_COLOR);
                label.setForeground(Color.WHITE);
                label.setFont(new Font("Segoe UI", Font.BOLD, 16));
                label.setHorizontalAlignment(JLabel.CENTER);
                label.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
                label.setOpaque(true);
                return label;
            }
        };
        
        // Apply custom renderer to all columns
        for (int i = 0; i < table.getColumnCount(); i++) {
            table.getColumnModel().getColumn(i).setHeaderRenderer(headerRenderer);
        }
        
        // Column widths
        table.getColumnModel().getColumn(0).setPreferredWidth(90);   // Book ID
        table.getColumnModel().getColumn(1).setPreferredWidth(280);  // Title
        table.getColumnModel().getColumn(2).setPreferredWidth(180);  // Author
        table.getColumnModel().getColumn(3).setPreferredWidth(180);  // Publisher
        table.getColumnModel().getColumn(4).setPreferredWidth(70);   // Year
        table.getColumnModel().getColumn(5).setPreferredWidth(140);  // ISBN
        table.getColumnModel().getColumn(6).setPreferredWidth(80);   // Copies
        
        JScrollPane scrollPane = new JScrollPane(table);
        scrollPane.setBorder(BorderFactory.createLineBorder(new Color(189, 195, 199), 2));
        scrollPane.getViewport().setBackground(Color.WHITE);
        
        // Ensure header is visible
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        scrollPane.setColumnHeaderView(table.getTableHeader());
        
        panel.add(scrollPane, BorderLayout.CENTER);
        
        return panel;
    }

    private JPanel createStatusBar() {
        JPanel statusBar = new JPanel(new FlowLayout(FlowLayout.LEFT));
        statusBar.setBackground(SECONDARY_COLOR);
        statusBar.setBorder(BorderFactory.createEmptyBorder(5, 10, 5, 10));
        
        statusLabel = new JLabel("📚 Total Books: 0");
        statusLabel.setFont(new Font("Segoe UI", Font.BOLD, 14));
        statusLabel.setForeground(Color.WHITE);
        statusBar.add(statusLabel);
        
        return statusBar;
    }

    private JTextField createStyledTextField(Font font) {
        JTextField field = new JTextField(20);
        field.setFont(font);
        field.setBorder(BorderFactory.createCompoundBorder(
            BorderFactory.createLineBorder(new Color(189, 195, 199), 1),
            BorderFactory.createEmptyBorder(5, 10, 5, 10)
        ));
        return field;
    }

    private JButton createStyledButton(String text, Color color) {
        JButton button = new JButton(text);
        button.setFont(new Font("Segoe UI", Font.BOLD, 16));
        button.setBackground(color);
        button.setForeground(Color.WHITE);
        button.setFocusPainted(false);
        button.setBorderPainted(false);
        button.setPreferredSize(new Dimension(140, 45));
        button.setCursor(new Cursor(Cursor.HAND_CURSOR));
        
        button.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                button.setBackground(color.darker());
            }
            public void mouseExited(MouseEvent e) {
                button.setBackground(color);
            }
        });
        
        return button;
    }

    private void addFormRow(JPanel panel, String label, JTextField field, 
                           GridBagConstraints gbc, int row, Font labelFont) {
        gbc.gridx = 0;
        gbc.gridy = row;
        gbc.weightx = 0.3;
        JLabel lbl = new JLabel(label);
        lbl.setFont(labelFont);
        lbl.setForeground(SECONDARY_COLOR);
        panel.add(lbl, gbc);
        
        gbc.gridx = 1;
        gbc.weightx = 0.7;
        panel.add(field, gbc);
    }

    private void addBook() {
        if (!validateFields()) {
            return;
        }
        
        // Check for duplicate Book ID
        String bookId = tfBookId.getText().trim();
        for (String[] book : books) {
            if (book[0].equals(bookId)) {
                showMessage("Error", "Book ID already exists!", JOptionPane.ERROR_MESSAGE);
                return;
            }
        }
        
        String[] book = {
            bookId,
            tfTitle.getText().trim(),
            tfAuthor.getText().trim(),
            tfPublisher.getText().trim(),
            tfYear.getText().trim(),
            tfIsbn.getText().trim(),
            tfCopies.getText().trim()
        };
        
        books.add(book);
        refreshTable();
        clearFields();
        showMessage("Success", "Book added successfully!", JOptionPane.INFORMATION_MESSAGE);
    }

    private void editBook() {
        String bookId = tfBookId.getText().trim();
        
        if (bookId.isEmpty()) {
            showMessage("Error", "Please enter Book ID to edit!", JOptionPane.ERROR_MESSAGE);
            return;
        }
        
        for (int i = 0; i < books.size(); i++) {
            if (books.get(i)[0].equals(bookId)) {
                if (!validateFields()) {
                    return;
                }
                
                String[] updatedBook = {
                    bookId,
                    tfTitle.getText().trim(),
                    tfAuthor.getText().trim(),
                    tfPublisher.getText().trim(),
                    tfYear.getText().trim(),
                    tfIsbn.getText().trim(),
                    tfCopies.getText().trim()
                };
                
                books.set(i, updatedBook);
                refreshTable();
                clearFields();
                showMessage("Success", "Book updated successfully!", JOptionPane.INFORMATION_MESSAGE);
                return;
            }
        }
        
        showMessage("Error", "Book not found! Would you like to add it?", JOptionPane.ERROR_MESSAGE);
    }

    private void deleteBook() {
        String bookId = tfBookId.getText().trim();
        
        if (bookId.isEmpty()) {
            showMessage("Error", "Please enter Book ID to delete!", JOptionPane.ERROR_MESSAGE);
            return;
        }
        
        for (int i = 0; i < books.size(); i++) {
            if (books.get(i)[0].equals(bookId)) {
                int confirm = JOptionPane.showConfirmDialog(
                    this,
                    "Are you sure you want to delete this book?",
                    "Confirm Delete",
                    JOptionPane.YES_NO_OPTION,
                    JOptionPane.WARNING_MESSAGE
                );
                
                if (confirm == JOptionPane.YES_OPTION) {
                    books.remove(i);
                    refreshTable();
                    clearFields();
                    showMessage("Success", "Book deleted successfully!", JOptionPane.INFORMATION_MESSAGE);
                }
                return;
            }
        }
        
        showMessage("Error", "Book not found!", JOptionPane.ERROR_MESSAGE);
    }

    private void searchBooks() {
        String searchTerm = tfSearch.getText().trim().toLowerCase();
        
        if (searchTerm.isEmpty()) {
            refreshTable();
            return;
        }
        
        tableModel.setRowCount(0);
        
        for (String[] book : books) {
            for (String field : book) {
                if (field.toLowerCase().contains(searchTerm)) {
                    tableModel.addRow(book);
                    break;
                }
            }
        }
    }

    private void refreshTable() {
        tableModel.setRowCount(0);
        for (String[] book : books) {
            tableModel.addRow(book);
        }
        updateStatus();
    }

    private void updateStatus() {
        statusLabel.setText("📚 Total Books: " + books.size());
    }

    private boolean validateFields() {
        if (tfBookId.getText().trim().isEmpty() ||
            tfTitle.getText().trim().isEmpty() ||
            tfAuthor.getText().trim().isEmpty()) {
            showMessage("Validation Error", "Book ID, Title, and Author are required!", 
                       JOptionPane.WARNING_MESSAGE);
            return false;
        }
        
        // Validate year
        String year = tfYear.getText().trim();
        if (!year.isEmpty() && !year.matches("\\d{4}")) {
            showMessage("Validation Error", "Year must be a 4-digit number!", 
                       JOptionPane.WARNING_MESSAGE);
            return false;
        }
        
        // Validate copies
        String copies = tfCopies.getText().trim();
        if (!copies.isEmpty() && !copies.matches("\\d+")) {
            showMessage("Validation Error", "Number of copies must be a valid number!", 
                       JOptionPane.WARNING_MESSAGE);
            return false;
        }
        
        return true;
    }

    private void clearFields() {
        tfBookId.setText("");
        tfTitle.setText("");
        tfAuthor.setText("");
        tfPublisher.setText("");
        tfYear.setText("");
        tfIsbn.setText("");
        tfCopies.setText("");
    }

    private void showMessage(String title, String message, int messageType) {
        JOptionPane.showMessageDialog(this, message, title, messageType);
    }

    public static void main(String[] args) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        SwingUtilities.invokeLater(() -> new LibraryManagement());
    }
}