import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private UserService selfProxy; // Self-injection для вызова из того же класса
    
    //Антипаттерн: @Transactional на private методе
    @Transactional
    private void badPrivateMethod(User user) {
        // Транзакции НЕ БУДЕТ! Метод не переопределяется прокси
        userRepository.save(user);
        if (user.getEmail() == null) {
            throw new RuntimeException("Ошибка — отката не будет!");
        }
    }
    
    //Правильно: public метод
    @Transactional
    public void goodPublicMethod(User user) {
        userRepository.save(user);
        if (user.getEmail() == null) {
            throw new RuntimeException("Ошибка — транзакция откатится");
        }
    }
    
    // Проблема внутреннего вызова
    public void callInternal() {
        User user = new User("John");
        //Транзакции не будет — вызов напрямую, не через прокси
        goodPublicMethod(user); // ФАКТИЧЕСКИ: this.goodPublicMethod()
    }
    
    //Решение: вызов через self-proxy
    public void callCorrectly() {
        User user = new User("John");
        selfProxy.goodPublicMethod(user); // Вызов через прокси — транзакция работает
    }
}

// Альтернативное решение: вынос логики в отдельный компонент
@Service
class InternalUserService {
    @Transactional
    public void doInTransaction(User user) {
        // транзакционная логика
    }
}

@Service
class MainUserService {
    @Autowired
    private InternalUserService internalService;
    
    public void call() {
        internalService.doInTransaction(new User("John")); // Транзакция работает
    }
}

@SpringBootApplication
public class TransactionalTricky implements CommandLineRunner {
    
    @Autowired
    private UserService userService;
    
    public static void main(String[] args) {
        SpringApplication.run(TransactionalTricky.class, args);
    }
    
    @Override
    public void run(String... args) {
        userService.saveUser();
        System.out.println(userService.getCounter());
    }
    
    @Service
    static class UserService {
        private int counter = 0;
        
        @Transactional
        public void saveUser() {
            privateIncrement();
        }
        
        @Transactional
        private void privateIncrement() {
            counter++;
        }
        
        public int getCounter() {
            return counter;
        }
    }
}

public class Book {
    private final String title;
    private final String author;
    private final int year;
    
    // Конструктор, геттеры
    // equals и hashCode НЕ переопределены!
}

// Две логически идентичные книги
Book book1 = new Book("1984", "George Orwell", 1949);
Book book2 = new Book("1984", "George Orwell", 1949);

// Создаём поток с дублированием
List<Book> library = Arrays.asList(book1, book1, book2, book2);

// Группировка по книге как ключу
Map<Book, Long> countByBook = library.stream()
    .collect(groupingBy(Function.identity(), counting()));

System.out.println(countByBook.size());  // Ожидаем 1, получаем...?

List<Book> uniqueBooks = library.stream()
    .distinct()
    .collect(toList());

Set<Book> bookSet = library.stream()
    .collect(toSet());

System.out.println(bookSet.size());  // Ожидаем 1, получаем 2

public class Author {
    private String name;  // Не final! Сеттер есть!
    private String country;
    
    // equals и hashCode по всем полям
    @Override public int hashCode() {
        return Objects.hash(name, country);
    }
}

// Группировка книг по автору
Map<Author, List<Book>> byAuthor = library.stream()
    .collect(groupingBy(Book::author));

// Позже в коде...
Author key = byAuthor.keySet().iterator().next();
key.setName("Modified Name");  // Мутация ключа!

// Попытка доступа
List<Book> books = byAuthor.get(key);  // null?!

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Book book = (Book) o;
    return year == book.year &&
           Objects.equals(title, book.title) &&
           Objects.equals(author, book.author);
}

@Override
public int hashCode() {
    return Objects.hash(title, author, year);
}

public record Book(String title, String author, int year) {}

// Автоматически: final поля, конструктор, геттеры, equals, hashCode, toString

import java.util.*;
import java.util.stream.Collectors;

public class Task100326 {
    public static void main(String[] args) {
        List<Item100326> items = Arrays.asList(
            new Item100326(1, "A"),
            new Item100326(1, "B"),
            new Item100326(2, "C"),
            new Item100326(2, "D")
        );
        
        Set<Item100326> set = new LinkedHashSet<>(items);
        
        Map<Integer, List<Item100326>> grouped = items.stream()
            .collect(Collectors.groupingBy(Item100326::getId));
        
        System.out.print(set.size() + " ");
        System.out.print(grouped.get(1).size() + " ");
        System.out.print(grouped.get(2).get(0).getName());
    }
    
    static class Item100326 {
        private int id;
        private String name;
        
        Item100326(int id, String name) {
            this.id = id;
            this.name = name;
        }
        
        public int getId() { return id; }
        public String getName() { return name; }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Item100326 item = (Item100326) o;
            return id == item.id;
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
}

import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import java.util.Objects;

//Антипаттерн: field injection
@Service
public class BadService {
    
    @Autowired
    private UserRepository userRepository; // не final, можно забыть проинициализировать
    
    @Autowired
    private EmailService emailService; // скрытая зависимость
    
    public void registerUser(User user) {
        // может быть NullPointerException, если забыли протестировать
        userRepository.save(user);
        emailService.sendWelcome(user);
    }
    
    // невозможно создать объект в тесте без Spring
}

//Правильно: constructor injection
@Service
public class GoodService {
    
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final AuditService auditService;
    
    // С одним конструктором @Autowired не нужен (Spring 4.3+)
    public GoodService(UserRepository userRepository, 
                      EmailService emailService,
                      @Lazy AuditService auditService) {
        this.userRepository = Objects.requireNonNull(userRepository, 
            "UserRepository must not be null");
        this.emailService = Objects.requireNonNull(emailService);
        this.auditService = auditService; // @Lazy — прокси будет создан при первом вызове
    }
    
    public void registerUser(User user) {
        userRepository.save(user);
        emailService.sendWelcome(user);
        auditService.log("User registered: " + user.getId());
    }
}

// Для циклических зависимостей — @Lazy
@Service
class A {
    private final B b;
    
    public A(@Lazy B b) { // B создастся лениво
        this.b = b;
    }
}

@Service
class B {
    private final A a;
    
    public B(A a) {
        this.a = a;
    }
}

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class Task110326 {
    public static void main(String[] args) {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Task110326.class)) {
            UserService110326 service = context.getBean(UserService110326.class);
            System.out.println(service.getUser());
        }
    }
}

@Component
class UserService110326 {
    private UserRepository110326 userRepository;

    @Autowired
    public UserService110326(UserRepository110326 userRepository) {
        this.userRepository = userRepository;
    }

    public String getUser() {
        return userRepository.findUser();
    }
}

@Component
class UserRepository110326 {
    private DatabaseService110326 databaseService;

    @Autowired
    public UserRepository110326(DatabaseService110326 databaseService) {
        this.databaseService = databaseService;
    }

    public String findUser() {
        return "User from " + databaseService.getDataSource();
    }
}

@Component
class DatabaseService110326 {
    public String getDataSource() {
        return "MainDB";
    }
}

List<Book> library = new ArrayList<>(fetchBooks());
Stream<Book> stream = library.stream();  // Поток создан, но не активирован

// Позже, до терминальной операции:
library.add(new Book("New", "Author", 2024));  // Модификация источника!

// Теперь терминальная операция:
List<Book> result = stream.collect(toList());  // ConcurrentModificationException?

// Катастрофа: модификация источника изнутри потока
library.stream()
    .filter(b -> b.year() < 1950)
    .forEach(library::remove);  // ConcurrentModificationException гарантирован

// Правильно: фильтрация через collect, не removeIf в потоке
List<Book> modernBooks = library.stream()
    .filter(b -> b.year() >= 1950)
    .collect(toList());

// Или без потока, если модификация исходной нужна:
library.removeIf(b -> b.year() < 1950);  // Метод коллекции, не Stream API

public class MutableBook {
    private String title;
    private int readCount;  // Мутабельное поле!
    
    public void incrementRead() { readCount++; }
}

// Антипаттерн: мутация внутри потока
List<MutableBook> books = fetchBooks();
books.stream()
    .filter(b -> b.getTitle().startsWith("A"))
    .forEach(MutableBook::incrementRead);  //Модифицируем исходные объекты!

// Теперь исходный список books изменён — побочный эффект

public record Book(String title, int readCount) {
    public Book withIncrementedRead() {
        return new Book(title, readCount + 1);  //Новый экземпляр
    }
}

// Правильно: создание новых объектов
List<Book> updatedBooks = books.stream()
    .filter(b -> b.title().startsWith("A"))
    .map(Book::withIncrementedRead)
    .collect(toList());

// Исходный список books неизменён