import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {
    
    @Autowired
    private AsyncService selfProxy; // self-injection
    
    @Async
    public CompletableFuture<String> asyncMethod() {
        System.out.println("Асинхронный вызов в потоке: " + Thread.currentThread().getName());
        return CompletableFuture.completedFuture("Результат");
    }
    
    //Проблема: прямой вызов
    public void badCall() {
        System.out.println("Прямой вызов");
        asyncMethod(); // this.asyncMethod() — асинхронности НЕТ!
    }
    
    //Решение: вызов через self-proxy
    public void goodCall() {
        System.out.println("Вызов через self-proxy");
        selfProxy.asyncMethod(); // через прокси — асинхронно
    }
}

// Альтернатива: отдельный компонент
@Service
class AsyncWorker {
    @Async
    public CompletableFuture<String> doWork() {
        return CompletableFuture.completedFuture("Работа выполнена");
    }
}

@Service
class CallerService {
    @Autowired
    private AsyncWorker worker;
    
    public void call() {
        worker.doWork(); // асинхронно через прокси
    }
}

@SpringBootApplication
@EnableAsync
public class Task130326 implements CommandLineRunner {

    @Autowired
    private AsyncService130326 service;

    public static void main(String[] args) {
        SpringApplication.run(Task130326.class, args);
    }

    @Override
    public void run(String... args) {
        service.directCall();
        service.proxyCall();
    }
}

@Component
class AsyncService130326 {
    @Lazy
    @Autowired
    private AsyncService130326 self;

    @Async
    public void asyncMethod() {
        System.out.println("asyncMethod: " + Thread.currentThread().getName());
    }

    public void directCall() {
        System.out.println("directCall: " + Thread.currentThread().getName());
        asyncMethod();
    }

    public void proxyCall() {
        System.out.println("proxyCall: " + Thread.currentThread().getName());
        self.asyncMethod();
    }
}

public class Book {
    private final String title;
    private final String author;
    
    public Book(String title, String author) {
        this.title = Objects.requireNonNull(title, "title не может быть null");
        this.author = Objects.requireNonNull(author, "author не может быть null");
    }
    
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    
    @Override
    public String toString() {
        return "Book[title=" + title + ", author=" + author + "]";
    }
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    Book book = (Book) o;
    return title.equals(book.title);  // Только title! Автор игнорируется.
}

public void demonstrateDistinctProblem() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),  // Другой автор!
        new Book("1984", "Оруэлл")
    );
    
    List<Book> distinct = books.stream()
        .distinct()
        .collect(Collectors.toList());
    
    System.out.println("Исходный список: " + books.size() + " книг");
    System.out.println("После distinct: " + distinct.size() + " книг");
    System.out.println("Уникальные книги: " + distinct);
}

Исходный список: 3 книг
После distinct: 2 книг
Уникальные книги: [Book[title=Война и мир, author=Толстой], Book[title=1984, author=Оруэлл]]

public void demonstrateToMapProblem() {
    List<Book> inventory = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский")
    );
    
    Map<Book, Integer> stock = inventory.stream()
        .collect(Collectors.toMap(
            Function.identity(),
            b -> 10,  // количество на складе
            (a, b) -> a + b  // слияние при коллизии
        ));
    
    System.out.println("Map: " + stock);
    
    // Попытка получить значение по «эквивалентной» книге
    Book lookup = new Book("Война и мир", "Толстой");
    System.out.println("Поиск " + lookup + ": " + stock.get(lookup));
    
    Book lookupWrongAuthor = new Book("Война и мир", "Гоголь");
    System.out.println("Поиск " + lookupWrongAuthor + ": " + stock.get(lookupWrongAuthor));
}

public void demonstrateGroupingProblem() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),
        new Book("Война и мир", "Тургенев")
    );
    
    Map<Book, List<Book>> byBook = books.stream()
        .collect(Collectors.groupingBy(Function.identity()));
    
    System.out.println("Групп: " + byBook.size());
    byBook.forEach((k, v) -> System.out.println(k + " -> " + v.size()));
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    Book book = (Book) o;
    return title.equals(book.title) && 
           author.equals(book.author);  // Теперь оба поля!
}

@Override
public int hashCode() {
    return Objects.hash(title, author);  // Консистентно с equals
}

public void demonstrateFixed() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),
        new Book("1984", "Оруэлл")
    );
    
    // distinct() — теперь 3 уникальные книги
    System.out.println("distinct: " + books.stream().distinct().count());
    
    // toMap — теперь 3 записи
    Map<Book, Integer> stock = books.stream()
        .collect(Collectors.toMap(
            Function.identity(),
            b -> 10,
            Integer::sum
        ));
    System.out.println("Map size: " + stock.size());
    
    // Поиск работает
    Book lookup = new Book("Война и мир", "Толстой");
    System.out.println("Найдено: " + stock.get(lookup));
}

private final String isbn;  // уникальный, неизменяемый

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    return isbn.equals(((Book) o).isbn);
}

@Override
public int hashCode() {
    return isbn.hashCode();
}

// Нет equals/hashCode — используем Object

public List<Book> findByTitle(String title) {
    return books.stream()
        .filter(b -> b.getTitle().equals(title))
        .collect(Collectors.toList());
}

private int hashCode;  // 0 = не вычислено

@Override
public int hashCode() {
    int result = hashCode;
    if (result == 0) {
        result = Objects.hash(title, author);
        hashCode = result;
    }
    return result;
}

public class Task160326 {
    public static void main(String[] args) {
        String s1 = "  hello  ".trim();
        String s2 = "  hello  ".strip();
        String s3 = "\u2000hello\u2000".trim();
        String s4 = "\u2000hello\u2000".strip();
        
        System.out.println(s1.equals(s2));
        System.out.println(s3.length());
        System.out.println(s4.length());
    }
}

@Entity
public class Order {
    @Id private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private User user; // ленивая загрузка
    
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private List<Item> items;
    // геттеры/сеттеры
}

@Service
public class OrderService {
    
    @PersistenceContext
    private EntityManager em;
    
    //Антипаттерн: сессия закрыта при доступе к ленивым полям
    public Order badFind(Long id) {
        Order order = em.find(Order.class, id);
        // Транзакция закончилась, сессия закрыта
        order.getUser().getName(); // LazyInitializationException!
        return order;
    }
    
    //Решение 1: @Transactional на уровне сервиса
    @Transactional
    public Order goodFindTransactional(Long id) {
        Order order = em.find(Order.class, id);
        order.getUser().getName(); // Ок, сессия открыта
        return order;
    }
    
    //Решение 2: JOIN FETCH в запросе
    @Transactional(readOnly = true)
    public Order findWithJoinFetch(Long id) {
        return em.createQuery(
            "SELECT o FROM Order o JOIN FETCH o.user WHERE o.id = :id", Order.class)
            .setParameter("id", id)
            .getSingleResult(); // user уже загружен
    }
    
    //Решение 3: EntityGraph
    @Transactional(readOnly = true)
    public Order findWithEntityGraph(Long id) {
        EntityGraph<?> graph = em.getEntityGraph("Order.withUserAndItems");
        return em.find(Order.class, id, 
            Collections.singletonMap("javax.persistence.fetchgraph", graph));
    }
}

// DTO-подход — лучшая практика
@Data
class OrderDTO {
    private Long id;
    private String userName; // только нужные поля, без прокси
}

@Service
class OrderDTOService {
    @PersistenceContext
    private EntityManager em;
    
    public OrderDTO findDTO(Long id) {
        return em.createQuery(
            "SELECT NEW com.example.OrderDTO(o.id, u.name) " +
            "FROM Order o JOIN o.user u WHERE o.id = :id", OrderDTO.class)
            .setParameter("id", id)
            .getSingleResult(); // Никаких прокси, только данные
    }
}