TelegaBot/src/main/java/ru/cathub/telegabot/service/impl/BookEditingServiceImpl.java

package ru.cathub.telegabot.service.impl;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import ru.cathub.telegabot.bot.KeyboardHelper;
import ru.cathub.telegabot.exception.ServiceException;
import ru.cathub.telegabot.model.Book;
import ru.cathub.telegabot.model.BookEditStateCache;
import ru.cathub.telegabot.model.BotUser;
import ru.cathub.telegabot.repository.BookRepository;
import ru.cathub.telegabot.repository.UserRepository;
import ru.cathub.telegabot.service.BookCacheService;
import ru.cathub.telegabot.service.BookEditingService;
import ru.cathub.telegabot.service.TelegramClientService;
import ru.cathub.telegabot.utils.Constants;

import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Optional;

import static ru.cathub.telegabot.bot.KeyboardHelper.getEditOptions;
import static ru.cathub.telegabot.utils.Constants.ERROR_DELETE_BOOKS;

@Service
@RequiredArgsConstructor
@Slf4j
public class BookEditingServiceImpl implements BookEditingService {

    private final BookCacheService bookCacheService;
    private final TelegramClientService telegramClientService;
    private final BookRepository bookRepository;
    private final UserRepository userRepository;

    @Override
    public void deleteBook(BotUser user) {
        try {
            var bookCache = bookCacheService.getBookEditCache(user.getId());
            if (bookCache == null || bookCache.getBookId() == null) {
                throw new ServiceException("Не найдена книга для удаления");
            }
            
            Long bookId = bookCache.getBookId();
            Optional<Book> book = bookRepository.findByIdAndBotUser(bookId, user);
            
            if (book.isPresent()) {
                bookRepository.deleteById(bookId);
                bookCacheService.clearBookEditCache(user.getId());
                telegramClientService.sendMessage(
                    user, 
                    "Книга успешно удалена \uD83D\uDDD1️", 
                    KeyboardHelper.getBookMenuKeyboard()
                );
            } else {
                throw new ServiceException(Constants.ERROR_BOOK_NOT_FOUND);
            }
        } catch (Exception e) {
            log.error("Error deleting book for user {}", user.getId(), e);
            telegramClientService.sendMessage(user,ERROR_DELETE_BOOKS);
        }
    }

    public void processBookSelection(BotUser user, Long bookId) {
        try {
            Optional<Book> book = bookRepository.findByIdAndBotUser(bookId, user);
            var bookCache = bookCacheService.getBookEditCache(user.getId());
            if (bookCache != null) {
                bookCache.setBookId(bookId);
            } else {
                bookCache = BookEditStateCache.builder().bookEditState(BookEditStateCache.BookEditState.NONE).bookId(bookId).build();
            }
            bookCacheService.updateBookEditCache(user.getId(), bookCache);
            book.ifPresentOrElse(
                b -> {
                    log.info("Found book with id {}", bookId);
                    telegramClientService.sendMessage(user, "Выберите поле для редактирования или удалите книгу:", getEditOptions(user));
                },
                () -> telegramClientService.sendMessage(user, Constants.ERROR_BOOK_NOT_FOUND)
            );
        } catch (NumberFormatException e) {
            log.error("Invalid book ID for user {}", user.getId(), e);
            telegramClientService.sendMessage(user, Constants.ERROR_INVALID_BOOK_ID);
        }
    }

    private void handleEditField(BotUser user, BookEditStateCache.BookEditState editState, String message) {
        var bookCache = bookCacheService.getBookEditCache(user.getId());
        bookCache.setBookEditState(editState);
        bookCacheService.updateBookEditCache(user.getId(), bookCache);
        telegramClientService.sendMessage(user, message);
    }

    public void handleEditTitle(BotUser user) {
        handleEditField(user, BookEditStateCache.BookEditState.EDITING_TITLE, "Введите новое название:");
    }

    public void handleEditAuthor(BotUser user) {
        handleEditField(user, BookEditStateCache.BookEditState.EDITING_AUTHOR, "Введите нового автора:");
    }

    public void handleEditRating(BotUser user) {
        handleEditField(user, BookEditStateCache.BookEditState.EDITING_RATING, "Введите рейтинг:");
    }

    @Override
    public void handleEditDate(BotUser user) {
        handleEditField(user, BookEditStateCache.BookEditState.EDITING_DATE, "Введите новую дату прочтения в формате ДД.ММ.ГГГГ:");
    }

    private void updateBookField(BotUser user, String newValue, String fieldName) {
        var bookEditState = bookCacheService.getBookEditCache(user.getId());
        Book book = bookRepository.findById(bookEditState.getBookId()).orElseThrow();

        switch (fieldName) {
            case "title":
                book.setTitle(newValue);
                telegramClientService.sendMessage(user, "Название успешно обновлено!");
                break;
            case "author":
                book.setAuthor(newValue);
                telegramClientService.sendMessage(user, "Автор успешно обновлен");
                break;
            case "rating":
                book.setRating(Integer.parseInt(newValue));
                telegramClientService.sendMessage(user, "Рейтинг успешно обновлен");
                break;
            case "date":
                try {
                    SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");
                    Date parsedDate = new Date(sdf.parse(newValue).getTime());
                    book.setReadDate(parsedDate);
                    telegramClientService.sendMessage(user, "Дата прочтения обновлена ✅");
                } catch (ParseException e) {
                    log.error("Invalid date format for user {}", user.getId(), e);
                    throw new IllegalArgumentException("Ошибка формата даты. Используйте ДД.ММ.ГГГГ");
                }
                break;
            default:
                log.error("Invalid field name {} for user {}", fieldName, user.getId());
                throw new IllegalArgumentException("Invalid field name: " + fieldName);
        }

        bookRepository.save(book);
        bookEditState.setBookEditState(BookEditStateCache.BookEditState.NONE);
        bookCacheService.updateBookEditCache(user.getId(), bookEditState);
        handleRestartMessage(user);
    }

    public void updateBookTitle(BotUser user, String newTitle) {
        updateBookField(user, newTitle, "title");
    }

    public void updateBookAuthor(BotUser user, String newAuthor) {
        updateBookField(user, newAuthor, "author");
    }

    public void updateBookRating(BotUser user, String newRating) {
        updateBookField(user, newRating, "rating");
    }

    @Override
    public void updateBookDate(BotUser user, String newDate) {
        updateBookField(user, newDate, "date");
    }

    @Override
    public void handleRestartMessage(BotUser botUser) {
        telegramClientService.sendMessageWithMarkdown(botUser, "Выберите действие \uD83D\uDCCB", KeyboardHelper.getBookMenuKeyboard());
    }
}