public class AudiobookListController {

    @FXML private TableView<Audiobook> audiobookTable;
    @FXML private TextField searchField;
    @FXML private ComboBox<Genre> genreComboBox;
    @FXML private Button addButton;
    @FXML private Button deleteButton;

    private Connection connection;
    private ObservableList<Audiobook> audiobooks;

    @FXML
    public void initialize() {
        // Підключення до бази даних
        try {
            connection = DriverManager.getConnection("jdbc:h2:./data/audiobook", "sa", "");
        } catch (SQLException e) {
            showError("Failed to connect to database: " + e.getMessage());
            return;
        }

        // Налаштування колонок таблиці
        titleColumn.setCellValueFactory(new PropertyValueFactory<>("title"));
        authorColumn.setCellValueFactory(cellData ->
            new SimpleStringProperty(cellData.getValue().getAuthor().getFullName())
        );
        durationColumn.setCellValueFactory(new PropertyValueFactory<>("duration"));

        // Завантаження жанрів
        loadGenres();

        // Завантаження аудіокниг
        loadAudiobooks();

        // Валідація пошукового поля
        searchField.textProperty().addListener((obs, old, newVal) -> {
            if (newVal.length() > 100) {
                searchField.setStyle("-fx-border-color: red;");
            } else {
                searchField.setStyle("");
            }
            filterAudiobooks(newVal);
        });

        // Активація кнопок залежно від вибору
        audiobookTable.getSelectionModel().selectedItemProperty().addListener((obs, old, newVal) -> {
            deleteButton.setDisable(newVal == null);
        });
    }

    private void loadGenres() {
        try (Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM genres")) {

            while (rs.next()) {
                Genre genre = new Genre(
                    UUID.fromString(rs.getString("id")),
                    rs.getString("name"),
                    rs.getString("description")
                );
                genreComboBox.getItems().add(genre);
            }
        } catch (SQLException e) {
            showError("Failed to load genres: " + e.getMessage());
        }
    }

    private void loadAudiobooks() {
        audiobooks = FXCollections.observableArrayList();

        String sql = """
            SELECT a.*, au.first_name, au.last_name, g.name as genre_name
            FROM audiobooks a
            JOIN authors au ON a.author_id = au.id
            JOIN genres g ON a.genre_id = g.id
            """;

        try (Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {

            while (rs.next()) {
                Author author = new Author(
                    UUID.fromString(rs.getString("author_id")),
                    rs.getString("first_name"),
                    rs.getString("last_name")
                );

                Genre genre = new Genre(
                    UUID.fromString(rs.getString("genre_id")),
                    rs.getString("genre_name"),
                    null
                );

                Audiobook audiobook = new Audiobook(
                    UUID.fromString(rs.getString("id")),
                    rs.getString("title"),
                    author,
                    genre,
                    rs.getInt("duration"),
                    rs.getInt("release_year")
                );

                audiobooks.add(audiobook);
            }

            audiobookTable.setItems(audiobooks);

        } catch (SQLException e) {
            showError("Failed to load audiobooks: " + e.getMessage());
        }
    }

    private void filterAudiobooks(String query) {
        if (query == null || query.isEmpty()) {
            audiobookTable.setItems(audiobooks);
            return;
        }

        ObservableList<Audiobook> filtered = audiobooks.filtered(audiobook ->
            audiobook.getTitle().toLowerCase().contains(query.toLowerCase()) ||
            audiobook.getAuthor().getFullName().toLowerCase().contains(query.toLowerCase())
        );

        audiobookTable.setItems(filtered);
    }

    @FXML
    private void onAddClicked() {
        // Відкриття діалогу додавання
        // ... ще 50 рядків коду
    }

    @FXML
    private void onDeleteClicked() {
        Audiobook selected = audiobookTable.getSelectionModel().getSelectedItem();
        if (selected == null) return;

        // Підтвердження видалення
        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
        alert.setTitle("Delete Audiobook");
        alert.setHeaderText("Are you sure?");
        alert.setContentText("Delete '" + selected.getTitle() + "'?");

        if (alert.showAndWait().get() == ButtonType.OK) {
            try (PreparedStatement stmt = connection.prepareStatement(
                    "DELETE FROM audiobooks WHERE id = ?")) {
                stmt.setString(1, selected.getId().toString());
                stmt.executeUpdate();

                audiobooks.remove(selected);

            } catch (SQLException e) {
                showError("Failed to delete audiobook: " + e.getMessage());
            }
        }
    }

    private void showError(String message) {
        Alert alert = new Alert(Alert.AlertType.ERROR);
        alert.setTitle("Error");
        alert.setContentText(message);
        alert.showAndWait();
    }
}

public class AudiobookListController {

    @FXML private TableView<Audiobook> audiobookTable;

    private AudiobookRepository repository;

    @FXML
    private void onDeleteClicked() {
        Audiobook selected = audiobookTable.getSelectionModel().getSelectedItem();

        // Оновлення Model
        repository.delete(selected.getId());

        // Ручне оновлення View (Model не сповіщає View автоматично)
        audiobookTable.getItems().remove(selected);

        // Оновлення статус-бару
        statusLabel.setText("Deleted: " + selected.getTitle());

        // Оновлення стану кнопок
        deleteButton.setDisable(true);
        editButton.setDisable(true);
    }
}

public interface IAudiobookListView {
    void setAudiobooks(List<Audiobook> audiobooks);
    void removeAudiobook(Audiobook audiobook);
    void showError(String message);
    void showSuccess(String message);
    void setDeleteButtonEnabled(boolean enabled);
    Audiobook getSelectedAudiobook();
}

public class AudiobookListView implements IAudiobookListView {

    @FXML private TableView<Audiobook> audiobookTable;
    @FXML private Button deleteButton;
    @FXML private Label statusLabel;

    private AudiobookListPresenter presenter;

    @FXML
    public void initialize() {
        // Створення Presenter (у реальному додатку через DI)
        AudiobookRepository repository = new JdbcAudiobookRepository(dataSource);
        presenter = new AudiobookListPresenter(this, repository);

        // Завантаження даних
        presenter.loadAudiobooks();

        // Делегування подій до Presenter
        audiobookTable.getSelectionModel().selectedItemProperty().addListener(
            (obs, old, newVal) -> presenter.onSelectionChanged(newVal)
        );
    }

    @FXML
    private void onDeleteClicked() {
        presenter.onDeleteClicked();
    }

    // Реалізація інтерфейсу IAudiobookListView

    @Override
    public void setAudiobooks(List<Audiobook> audiobooks) {
        audiobookTable.getItems().setAll(audiobooks);
    }

    @Override
    public void removeAudiobook(Audiobook audiobook) {
        audiobookTable.getItems().remove(audiobook);
    }

    @Override
    public void showError(String message) {
        statusLabel.setText("Error: " + message);
        statusLabel.setStyle("-fx-text-fill: red;");
    }

    @Override
    public void showSuccess(String message) {
        statusLabel.setText(message);
        statusLabel.setStyle("-fx-text-fill: green;");
    }

    @Override
    public void setDeleteButtonEnabled(boolean enabled) {
        deleteButton.setDisable(!enabled);
    }

    @Override
    public Audiobook getSelectedAudiobook() {
        return audiobookTable.getSelectionModel().getSelectedItem();
    }
}

public class AudiobookListPresenter {

    private final IAudiobookListView view;
    private final AudiobookRepository repository;

    public AudiobookListPresenter(IAudiobookListView view, AudiobookRepository repository) {
        this.view = view;
        this.repository = repository;
    }

    public void loadAudiobooks() {
        try {
            List<Audiobook> audiobooks = repository.findAll();
            view.setAudiobooks(audiobooks);
        } catch (DataAccessException e) {
            view.showError("Failed to load audiobooks: " + e.getMessage());
        }
    }

    public void onDeleteClicked() {
        Audiobook selected = view.getSelectedAudiobook();
        if (selected == null) {
            view.showError("No audiobook selected");
            return;
        }

        try {
            repository.delete(selected.getId());
            view.removeAudiobook(selected);
            view.showSuccess("Deleted: " + selected.getTitle());
            view.setDeleteButtonEnabled(false);
        } catch (DataAccessException e) {
            view.showError("Failed to delete: " + e.getMessage());
        }
    }

    public void onSelectionChanged(Audiobook selected) {
        view.setDeleteButtonEnabled(selected != null);
    }
}

@Test
void shouldDeleteSelectedAudiobook() {
    // Given
    IAudiobookListView mockView = mock(IAudiobookListView.class);
    AudiobookRepository mockRepo = mock(AudiobookRepository.class);
    AudiobookListPresenter presenter = new AudiobookListPresenter(mockView, mockRepo);

    Audiobook audiobook = new Audiobook("1984", orwell, dystopian, 360);
    when(mockView.getSelectedAudiobook()).thenReturn(audiobook);

    // When
    presenter.onDeleteClicked();

    // Then
    verify(mockRepo).delete(audiobook.getId());
    verify(mockView).removeAudiobook(audiobook);
    verify(mockView).showSuccess(contains("Deleted"));
}

view.setTitle("New Title");
view.setDeleteButtonEnabled(false);

// ViewModel
titleProperty.set("New Title");
deleteButtonEnabledProperty.set(false);

// View (FXML або код)
label.textProperty().bind(viewModel.titleProperty());
deleteButton.disableProperty().bind(viewModel.deleteButtonEnabledProperty().not());

public class AudiobookListViewModel {

    // Properties для UI
    private final ObservableList<AudiobookViewModel> audiobooks = FXCollections.observableArrayList();
    private final ObjectProperty<AudiobookViewModel> selectedAudiobook = new SimpleObjectProperty<>();
    private final StringProperty statusMessage = new SimpleStringProperty("");
    private final BooleanProperty isLoading = new SimpleBooleanProperty(false);

    // Computed Properties
    private final BooleanBinding deleteButtonEnabled;

    // Залежності
    private final AudiobookRepository repository;

    public AudiobookListViewModel(AudiobookRepository repository) {
        this.repository = repository;

        // Кнопка Delete активна лише коли щось обрано
        deleteButtonEnabled = selectedAudiobook.isNotNull();
    }

    public void loadAudiobooks() {
        isLoading.set(true);

        // У реальному додатку це буде асинхронно через Task
        try {
            List<Audiobook> result = repository.findAll();
            audiobooks.setAll(result.stream()
                .map(AudiobookViewModel::new)
                .collect(Collectors.toList()));
            statusMessage.set("Loaded " + result.size() + " audiobooks");
        } catch (DataAccessException e) {
            statusMessage.set("Error: " + e.getMessage());
        } finally {
            isLoading.set(false);
        }
    }

    public void deleteSelected() {
        AudiobookViewModel selected = selectedAudiobook.get();
        if (selected == null) return;

        try {
            repository.delete(selected.getAudiobook().getId());
            audiobooks.remove(selected);
            selectedAudiobook.set(null);
            statusMessage.set("Deleted: " + selected.getTitle());
        } catch (DataAccessException e) {
            statusMessage.set("Error: " + e.getMessage());
        }
    }

    // Getters для Properties
    public ObservableList<AudiobookViewModel> getAudiobooks() { return audiobooks; }
    public ObjectProperty<AudiobookViewModel> selectedAudiobookProperty() { return selectedAudiobook; }
    public StringProperty statusMessageProperty() { return statusMessage; }
    public BooleanProperty isLoadingProperty() { return isLoading; }
    public BooleanBinding deleteButtonEnabledProperty() { return deleteButtonEnabled; }
}

public class AudiobookViewModel {

    private final Audiobook audiobook;

    private final StringProperty title;
    private final StringProperty authorName;
    private final StringProperty formattedDuration;

    public AudiobookViewModel(Audiobook audiobook) {
        this.audiobook = audiobook;
        this.title = new SimpleStringProperty(audiobook.getTitle());
        this.authorName = new SimpleStringProperty(audiobook.getAuthor().getFullName());
        this.formattedDuration = new SimpleStringProperty(formatDuration(audiobook.getDuration()));
    }

    private String formatDuration(int minutes) {
        int hours = minutes / 60;
        int mins = minutes % 60;
        return String.format("%dh %dm", hours, mins);
    }

    // Properties для TableView
    public StringProperty titleProperty() { return title; }
    public StringProperty authorNameProperty() { return authorName; }
    public StringProperty formattedDurationProperty() { return formattedDuration; }

    // Getters
    public String getTitle() { return title.get(); }
    public Audiobook getAudiobook() { return audiobook; }
}

public class AudiobookListController {

    @FXML private TableView<AudiobookViewModel> audiobookTable;
    @FXML private TableColumn<AudiobookViewModel, String> titleColumn;
    @FXML private TableColumn<AudiobookViewModel, String> authorColumn;
    @FXML private TableColumn<AudiobookViewModel, String> durationColumn;

    @FXML private Button deleteButton;
    @FXML private Label statusLabel;
    @FXML private ProgressIndicator loadingIndicator;

    private AudiobookListViewModel viewModel;

    @FXML
    public void initialize() {
        // Створення ViewModel (у реальному додатку через Guice)
        AudiobookRepository repository = new JdbcAudiobookRepository(dataSource);
        viewModel = new AudiobookListViewModel(repository);

        // Налаштування колонок
        titleColumn.setCellValueFactory(cellData -> cellData.getValue().titleProperty());
        authorColumn.setCellValueFactory(cellData -> cellData.getValue().authorNameProperty());
        durationColumn.setCellValueFactory(cellData -> cellData.getValue().formattedDurationProperty());

        // Bindings: ViewModel → View
        audiobookTable.setItems(viewModel.getAudiobooks());
        audiobookTable.getSelectionModel().selectedItemProperty()
            .bindBidirectional(viewModel.selectedAudiobookProperty());

        statusLabel.textProperty().bind(viewModel.statusMessageProperty());
        deleteButton.disableProperty().bind(viewModel.deleteButtonEnabledProperty().not());
        loadingIndicator.visibleProperty().bind(viewModel.isLoadingProperty());

        // Завантаження даних
        viewModel.loadAudiobooks();
    }

    @FXML
    private void onDeleteClicked() {
        viewModel.deleteSelected();
    }
}

@Test
void shouldDisableDeleteButtonWhenNothingSelected() {
    // Given
    AudiobookListViewModel viewModel = new AudiobookListViewModel(mockRepository);

    // When
    viewModel.selectedAudiobookProperty().set(null);

    // Then
    assertFalse(viewModel.deleteButtonEnabledProperty().get());
}

@Test
void shouldLoadAudiobooks() {
    // Given
    AudiobookRepository mockRepo = mock(AudiobookRepository.class);
    when(mockRepo.findAll()).thenReturn(List.of(audiobook1, audiobook2));

    AudiobookListViewModel viewModel = new AudiobookListViewModel(mockRepo);

    // When
    viewModel.loadAudiobooks();

    // Then
    assertEquals(2, viewModel.getAudiobooks().size());
    assertEquals("Loaded 2 audiobooks", viewModel.statusMessageProperty().get());
}

// Фрагмент A
public class UserController {
    @FXML private TextField nameField;
    private UserPresenter presenter;

    @FXML
    public void initialize() {
        presenter = new UserPresenter(this);
    }

    public void setName(String name) {
        nameField.setText(name);
    }
}

// Фрагмент B
public class UserViewModel {
    private final StringProperty name = new SimpleStringProperty();

    public StringProperty nameProperty() { return name; }
}

public class UserController {
    @FXML private TextField nameField;
    private UserViewModel viewModel;

    @FXML
    public void initialize() {
        nameField.textProperty().bind(viewModel.nameProperty());
    }
}

public class ProductViewModel {
    private final TableView<Product> productTable; // Порушення?

    public ProductViewModel(TableView<Product> table) {
        this.productTable = table;
    }

    public void loadProducts() {
        List<Product> products = repository.findAll();
        productTable.getItems().setAll(products); // Порушення?
    }
}

public class BookListController {
    @FXML private TableView<Book> bookTable;
    @FXML private Button deleteButton;

    private Connection connection;

    @FXML
    public void initialize() {
        connection = DriverManager.getConnection("jdbc:h2:./books", "sa", "");
        loadBooks();
    }

    private void loadBooks() {
        try (Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM books")) {
            while (rs.next()) {
                Book book = new Book(rs.getString("title"), rs.getString("author"));
                bookTable.getItems().add(book);
            }
        } catch (SQLException e) {
            showError(e.getMessage());
        }
    }

    @FXML
    private void onDeleteClicked() {
        Book selected = bookTable.getSelectionModel().getSelectedItem();
        // ... SQL DELETE
        bookTable.getItems().remove(selected);
    }
}

// MVP
public interface IProductView {
    void setProducts(List<Product> products);
    void setTotalPrice(double price);
    void showError(String message);
}

public class ProductPresenter {
    private final IProductView view;

    public void loadProducts() {
        List<Product> products = repository.findAll();
        view.setProducts(products);

        double total = products.stream().mapToDouble(Product::getPrice).sum();
        view.setTotalPrice(total);
    }
}