import java.util.concurrent.ConcurrentHashMap;

public class Task060126 {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        Integer result = map.computeIfAbsent("a", k -> map.computeIfAbsent("a", k2 -> 2));

        System.out.println(result);
    }
}

@Service
public class TaskProducer {
    private final RabbitTemplate rabbitTemplate;
    
    @Value("${app.queues.task-queue}")
    private String taskQueue;
    
    public void sendTask(Task task) {
        rabbitTemplate.convertAndSend(taskQueue, task, message -> {
            // Установка приоритета задачи
            message.getMessageProperties().setPriority(task.getPriority());
            // Время жизни сообщения
            message.getMessageProperties().setExpiration("3600000"); // 1 час
            return message;
        });
    }
}

@Component
public class TaskWorker {
    
    @RabbitListener(queues = "${app.queues.task-queue}")
    public void processTask(Task task, Channel channel, 
                           @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) {
        try {
            // Обработка задачи
            boolean success = executeTask(task);
            
            if (success) {
                // Подтверждение успешной обработки
                channel.basicAck(deliveryTag, false);
                log.info("Task {} processed successfully", task.getId());
            } else {
                // Отказ без повторной очереди (перемещение в DLQ)
                channel.basicNack(deliveryTag, false, false);
                log.error("Task {} failed, moved to DLQ", task.getId());
            }
        } catch (Exception e) {
            // При ошибке - повторная очередь
            channel.basicNack(deliveryTag, false, true);
            log.error("Error processing task {}, requeued", task.getId(), e);
        }
    }
    
    private boolean executeTask(Task task) {
        // Логика обработки задачи
        return true;
    }
}

@Configuration
public class WorkQueueConfig {
    
    @Bean
    public Queue taskQueue() {
        return QueueBuilder.durable("tasks.queue")
            .withArgument("x-max-priority", 10) // Поддержка приоритетов
            .withArgument("x-dead-letter-exchange", "dlx.exchange")
            .build();
    }
    
    @Bean
    public SimpleRabbitListenerContainerFactory workerFactory(
            ConnectionFactory connectionFactory) {
        
        SimpleRabbitListenerContainerFactory factory = 
            new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        
        // Критичная настройка для равномерного распределения
        factory.setPrefetchCount(1); // По одному сообщению на consumer
        factory.setConcurrentConsumers(3); // Три параллельных worker'а
        factory.setMaxConcurrentConsumers(10); // Автомасштабирование при нагрузке
        
        // Ручные подтверждения для контроля
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        
        return factory;
    }
}

@Configuration
public class PubSubConfig {
    
    @Bean
    public FanoutExchange notificationsExchange() {
        return new FanoutExchange("notifications.fanout", true, false);
    }
    
    @Bean
    public Queue auditQueue() {
        return new Queue("notifications.audit.queue", true);
    }
    
    @Bean
    public Queue cacheQueue() {
        return new Queue("notifications.cache.queue", true);
    }
    
    @Bean
    public Queue analyticsQueue() {
        return new Queue("notifications.analytics.queue", true);
    }
    
    @Bean
    public Binding auditBinding() {
        return BindingBuilder.bind(auditQueue())
            .to(notificationsExchange());
    }
    
    @Bean
    public Binding cacheBinding() {
        return BindingBuilder.bind(cacheQueue())
            .to(notificationsExchange());
    }
    
    @Bean
    public Binding analyticsBinding() {
        return BindingBuilder.bind(analyticsQueue())
            .to(notificationsExchange());
    }
}

@Service
public class NotificationPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    public void publishNotification(Notification notification) {
        // Отправка в fanout exchange - все подписчики получат копию
        rabbitTemplate.convertAndSend(
            "notifications.fanout", 
            "", // routing key игнорируется для fanout
            notification
        );
    }
}

@Component
public class AuditNotificationConsumer {
    
    @RabbitListener(queues = "notifications.audit.queue")
    public void handleNotification(Notification notification) {
        // Каждый consumer обрабатывает свою копию сообщения
        auditService.logEvent(notification);
    }
}

@Configuration
public class TopicRoutingConfig {
    
    @Bean
    public TopicExchange stockExchange() {
        return new TopicExchange("stock.topic", true, false);
    }
    
    @Bean
    public Queue usdStockQueue() {
        return new Queue("stock.usd.queue", true);
    }
    
    @Bean
    public Queue eurStockQueue() {
        return new Queue("stock.eur.queue", true);
    }
    
    @Bean
    public Queue allStockQueue() {
        return new Queue("stock.all.queue", true);
    }
    
    @Bean
    public Binding usdBinding() {
        // Будет получать: stock.usd.nyse, stock.usd.nasdaq
        return BindingBuilder.bind(usdStockQueue())
            .to(stockExchange())
            .with("stock.usd.*");
    }
    
    @Bean
    public Binding eurBinding() {
        // Будет получать: stock.eur.lse, stock.eur.euronext
        return BindingBuilder.bind(eurStockQueue())
            .to(stockExchange())
            .with("stock.eur.*");
    }
    
    @Bean
    public Binding allStocksBinding() {
        // Будет получать все сообщения о stock
        return BindingBuilder.bind(allStockQueue())
            .to(stockExchange())
            .with("stock.#");
    }
}

@Service
public class StockPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    public void publishUSDPrice(String exchange, BigDecimal price) {
        String routingKey = "stock.usd." + exchange.toLowerCase();
        StockUpdate update = new StockUpdate("USD", exchange, price);
        
        rabbitTemplate.convertAndSend(
            "stock.topic", 
            routingKey, 
            update
        );
    }
    
    public void publishEURPrice(String exchange, BigDecimal price) {
        String routingKey = "stock.eur." + exchange.toLowerCase();
        StockUpdate update = new StockUpdate("EUR", exchange, price);
        
        rabbitTemplate.convertAndSend(
            "stock.topic", 
            routingKey, 
            update
        );
    }
}

@Service
public class CalculatorRpcClient {
    private final RabbitTemplate rabbitTemplate;
    
    public CalculatorRpcClient(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        
        // Настройка reply listener
        this.rabbitTemplate.setReplyTimeout(30000);
        this.rabbitTemplate.setUseDirectReplyToContainer(false);
    }
    
    public BigDecimal calculate(CalculationRequest request) {
        // Создание correlation ID
        String correlationId = UUID.randomUUID().toString();
        
        // Отправка запроса и ожидание ответа
        CalculationResponse response = (CalculationResponse) 
            rabbitTemplate.convertSendAndReceive(
                "rpc.exchange",
                "calculator.rpc",
                request,
                message -> {
                    message.getMessageProperties()
                        .setCorrelationId(correlationId);
                    message.getMessageProperties()
                        .setReplyTo("amq.rabbitmq.reply-to"); // Временная очередь
                    return message;
                }
            );
        
        if (response == null) {
            throw new RuntimeException("RPC timeout");
        }
        
        return response.getResult();
    }
}

@Component
public class CalculatorRpcServer {
    
    @RabbitListener(
        bindings = @QueueBinding(
            value = @Queue(value = "rpc.calculator.queue", durable = "true"),
            exchange = @Exchange(value = "rpc.exchange", type = ExchangeTypes.DIRECT),
            key = "calculator.rpc"
        )
    )
    public CalculationResponse calculate(CalculationRequest request,
                                        Message message) {
        
        String correlationId = message.getMessageProperties()
            .getCorrelationId();
        String replyTo = message.getMessageProperties()
            .getReplyTo();
        
        log.debug("Processing RPC request {} from {}", 
                 correlationId, replyTo);
        
        // Выполнение расчета
        BigDecimal result = performCalculation(request);
        
        // Возврат результата с сохранением correlationId
        CalculationResponse response = new CalculationResponse(result);
        
        // CorrelationId автоматически копируется в ответ
        return response;
    }
    
    private BigDecimal performCalculation(CalculationRequest request) {
        // Логика расчета
        return BigDecimal.ZERO;
    }
}

// Producer без подтверждений
@Bean
public RabbitTemplate atMostOnceTemplate(ConnectionFactory cf) {
    RabbitTemplate template = new RabbitTemplate(cf);
    template.setMandatory(false);
    
    // Отключение publisher confirms
    ((CachingConnectionFactory) cf)
        .setPublisherConfirmType(CachingConnectionFactory.ConfirmType.NONE);
    
    return template;
}

// Consumer с auto-ack
@RabbitListener(queues = "at.most.once.queue")
public void handleAutoAck(Message message) {
    // Сообщение уже удалено из очереди при доставке
    // При падении здесь - сообщение потеряно
    processMessage(message);
}

@Component
public class AtLeastOnceConsumer {
    
    @RabbitListener(queues = "orders.queue")
    public void processOrder(Order order, Channel channel,
                            @Header(AmqpHeaders.DELIVERY_TAG) long tag) {
        
        try {
            // 1. Обработка заказа
            processOrderSafely(order);
            
            // 2. Подтверждение после успешной обработки
            channel.basicAck(tag, false);
            
            log.info("Order {} processed and acknowledged", order.getId());
            
        } catch (Exception e) {
            // 3. При ошибке - повторная очередь
            channel.basicNack(tag, false, true);
            log.error("Order processing failed, requeued", e);
            
            // Идемпотентность критична!
            // При повторной обработке должна быть сохранена консистентность
        }
    }
    
    private void processOrderSafely(Order order) {
        // Идемпотентная обработка
        if (orderRepository.existsById(order.getId())) {
            log.warn("Duplicate order {}, skipping", order.getId());
            return;
        }
        
        orderRepository.save(order);
        inventoryService.reserveItems(order);
    }
}

@Service
@Transactional
public class ExactlyOnceProcessor {
    
    private final RabbitTemplate rabbitTemplate;
    private final OrderRepository orderRepository;
    
    public void processWithExactlyOnceSemantics(OrderMessage message) {
        // 1. Проверка идемпотентности
        if (processedMessageRepository.existsById(message.getId())) {
            return; // Уже обработано
        }
        
        // 2. Сохранение в outbox паттерн
        OrderOutbox outbox = new OrderOutbox();
        outbox.setMessageId(message.getId());
        outbox.setOrderData(message.getPayload());
        outbox.setStatus(OutboxStatus.PROCESSING);
        
        orderRepository.save(outbox);
        
        // 3. Бизнес-логика в транзакции
        Order order = createOrder(message);
        orderRepository.save(order);
        
        // 4. Обновление статуса в той же транзакции
        outbox.setStatus(OutboxStatus.PROCESSED);
        orderRepository.save(outbox);
        
        // 5. Отправка подтверждения (после коммита транзакции)
        // RabbitTemplate работает после завершения транзакции
        rabbitTemplate.convertAndSend(
            "order.processed.exchange",
            "order.processed",
            new OrderProcessedEvent(order.getId())
        );
        
        // 6. Идемпотентность на стороне получателя подтверждения
    }
    
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void afterCommit(OrderProcessedEvent event) {
        // Только после успешного коммита
        rabbitTemplate.convertAndSend(
            "order.completed.queue",
            event
        );
    }
}

@Configuration
public class PublisherConfirmConfig {
    
    @Bean
    public CachingConnectionFactory confirmedConnectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        
        // Включение publisher confirms
        factory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);
        factory.setPublisherReturns(true);
        
        return factory;
    }
    
    @Bean
    public RabbitTemplate confirmedRabbitTemplate(
            CachingConnectionFactory connectionFactory) {
        
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        
        // Callback для подтверждений
        template.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                metrics.increment("publisher.confirms.success");
            } else {
                metrics.increment("publisher.confirms.failure");
                log.error("Message not confirmed: {}", cause);
                
                // Логика повторной отправки
                if (correlationData != null) {
                    retryService.scheduleRetry(correlationData.getId());
                }
            }
        });
        
        // Callback для возвращенных сообщений
        template.setReturnsCallback(returned -> {
            log.error("Message returned: {}", returned.toString());
            returnedMessageService.handleReturned(returned);
        });
        
        return template;
    }
}

public class AcknowledgementExamples {
    
    // 1. Автоматическое подтверждение (ненадежно)
    @RabbitListener(queues = "auto.ack.queue")
    public void autoAck(Message message) {
        // Подтверждение происходит автоматически при возврате метода
    }
    
    // 2. Ручное подтверждение (рекомендуется)
    @RabbitListener(queues = "manual.ack.queue")
    public void manualAck(Order order, Channel channel,
                         @Header(AmqpHeaders.DELIVERY_TAG) long tag) {
        
        try {
            process(order);
            channel.basicAck(tag, false); // Положительное подтверждение
        } catch (BusinessException e) {
            // Не requeue для бизнес-ошибок
            channel.basicNack(tag, false, false);
        } catch (TechnicalException e) {
            // Requeue для технических ошибок
            channel.basicNack(tag, false, true);
        }
    }
    
    // 3. Подтверждение с транзакцией
    @Transactional
    @RabbitListener(queues = "transactional.queue")
    public void transactionalAck(Payment payment, Channel channel,
                                @Header(AmqpHeaders.DELIVERY_TAG) long tag) {
        
        // Сохранение в БД
        paymentRepository.save(payment);
        
        // Подтверждение произойдет только после коммита транзакции
        // При откате транзакции - сообщение вернется в очередь
    }
}

@Service
public class TransactionalMessageService {
    
    private final RabbitTemplate rabbitTemplate;
    
    @Transactional
    public void processInTransaction(Order order) {
        // 1. Сохранение в базу данных
        orderRepository.save(order);
        
        // 2. Отправка сообщения в той же транзакции
        rabbitTemplate.execute(channel -> {
            // Начало транзакции RabbitMQ
            channel.txSelect();
            
            try {
                // Отправка сообщения
                channel.basicPublish(
                    "orders.exchange",
                    "order.created",
                    null,
                    serialize(order)
                );
                
                // Коммит транзакции RabbitMQ
                channel.txCommit();
                
                return null;
            } catch (Exception e) {
                // Откат транзакции RabbitMQ
                channel.txRollback();
                throw new RuntimeException("Transaction failed", e);
            }
        });
        
        // 3. Если произойдет исключение здесь, 
        // откатятся и БД и сообщение RabbitMQ
        inventoryService.updateStock(order);
    }
}

@Configuration
public class DeadLetterConfig {
    
    // Основной DLX
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("dlx.exchange", true, false);
    }
    
    // Очередь для мертвых писем
    @Bean
    public Queue dlQueue() {
        return QueueBuilder.durable("dead.letter.queue")
            .withArgument("x-max-length", 10000) // Ограничение размера
            .withArgument("x-message-ttl", 86400000) // 24 часа хранения
            .build();
    }
    
    @Bean
    public Binding dlBinding() {
        return BindingBuilder.bind(dlQueue())
            .to(dlxExchange())
            .with("#"); // Все routing keys
    }
    
    // Рабочая очередь с настройкой DLX
    @Bean
    public Queue orderProcessingQueue() {
        return QueueBuilder.durable("orders.processing.queue")
            .withArgument("x-dead-letter-exchange", "dlx.exchange")
            .withArgument("x-dead-letter-routing-key", "orders.failed")
            .withArgument("x-max-retries", 3) // Кастомный аргумент
            .build();
    }
}

@Component
public class DeadLetterProcessor {
    
    @RabbitListener(queues = "dead.letter.queue")
    public void handleDeadLetter(Message failedMessage,
                                Channel channel,
                                @Header(AmqpHeaders.DELIVERY_TAG) long tag,
                                @Header(AmqpHeaders.RECEIVED_ROUTING_KEY) String routingKey,
                                @Header(AmqpHeaders.RECEIVED_EXCHANGE) String exchange,
                                @Header("x-death") List<Map<String, Object>> deaths) {
        
        // Анализ причины попадания в DLQ
        String reason = analyzeFailureReason(deaths);
        
        log.error("Dead letter received: routingKey={}, reason={}, deaths={}", 
                 routingKey, reason, deaths);
        
        // Логика обработки в зависимости от причины
        if (isRecoverable(failedMessage, deaths)) {
            handleRecoverableMessage(failedMessage);
        } else {
            handlePermanentFailure(failedMessage);
        }
        
        // Подтверждение обработки DLQ
        channel.basicAck(tag, false);
    }
    
    private String analyzeFailureReason(List<Map<String, Object>> deaths) {
        if (deaths != null && !deaths.isEmpty()) {
            Map<String, Object> lastDeath = deaths.get(0);
            return (String) lastDeath.get("reason");
        }
        return "unknown";
    }
    
    private void handleRecoverableMessage(Message message) {
        // Пример: повторная отправка после задержки
        String originalQueue = extractOriginalQueue(message);
        long delay = calculateRetryDelay(message);
        
        retryService.scheduleRetry(message, originalQueue, delay);
    }
    
    private void handlePermanentFailure(Message message) {
        // Архивирование неудачных сообщений
        archiveService.archiveFailedMessage(message);
        
        // Уведомление команды поддержки
        alertService.notifySupportTeam(message);
    }
}

@Configuration
public class DelayedRetryConfig {
    
    // Exchange для отложенных повторных попыток
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        
        return new CustomExchange(
            "delayed.retry.exchange",
            "x-delayed-message",
            true,
            false,
            args
        );
    }
    
    // Очередь для отложенных повторных попыток
    @Bean
    public Queue delayedRetryQueue() {
        return new Queue("delayed.retry.queue", true);
    }
    
    @Bean
    public Binding delayedBinding() {
        return BindingBuilder.bind(delayedRetryQueue())
            .to(delayedExchange())
            .with("retry.key")
            .noargs();
    }
    
    // Сервис для отложенных повторных попыток
    @Service
    public class DelayedRetryService {
        private final RabbitTemplate rabbitTemplate;
        
        public void scheduleRetry(Message message, int attempt) {
            long delay = calculateExponentialBackoff(attempt);
            
            rabbitTemplate.convertAndSend(
                "delayed.retry.exchange",
                "retry.key",
                message,
                m -> {
                    // Установка задержки
                    m.getMessageProperties()
                        .setHeader("x-delay", delay);
                    
                    // Сохранение номера попытки
                    m.getMessageProperties()
                        .setHeader("retry-attempt", attempt);
                    
                    return m;
                }
            );
        }
        
        private long calculateExponentialBackoff(int attempt) {
            return (long) Math.pow(2, attempt) * 1000; // Экспоненциальная задержка
        }
    }
}

public class Task070126 {
    public static void main(String[] args) {
        new Child070126();
    }
}

class Parent070126 {
    Parent070126() {
        print();
    }
    
    void print() {
        System.out.println("Parent");
    }
}

class Child070126 extends Parent070126 {
    private String value = "Hello";
    
    Child070126() {
        System.out.println("Child constructor");
    }
    
    @Override
    void print() {
        System.out.println(value.length());
    }
}

public class LinearSearch {
    public static Contact findContact(List<Contact> contacts, String name) {
        for (Contact contact : contacts) {
            if (contact.getName().equals(name)) {
                return contact;
            }
        }
        return null; // Контакт не найден
    }
}

public class IndexedSearch {
    private Map<String, Contact> contactIndex;
    
    public IndexedSearch(List<Contact> contacts) {
        // Предварительная обработка: построение индекса
        contactIndex = new HashMap<>();
        for (Contact contact : contacts) {
            contactIndex.put(contact.getName(), contact);
        }
    }
    
    public Contact findContact(String name) {
        // Поиск по индексу за постоянное время
        return contactIndex.get(name);
    }
}

public class CachedSearch {
    private List<Contact> contacts;
    private Map<String, Contact> cache;
    private int cacheHits = 0;
    private int cacheMisses = 0;
    
    public CachedSearch(List<Contact> contacts) {
        this.contacts = contacts;
        this.cache = new HashMap<>();
    }
    
    public Contact findContact(String name) {
        // Проверка кэша
        Contact cached = cache.get(name);
        if (cached != null) {
            cacheHits++;
            return cached;
        }
        
        // Кэш-промах: выполняем линейный поиск
        cacheMisses++;
        for (Contact contact : contacts) {
            if (contact.getName().equals(name)) {
                // Сохраняем результат в кэш для будущих запросов
                cache.put(name, contact);
                return contact;
            }
        }
        return null;
    }
    
    public double getCacheHitRatio() {
        int total = cacheHits + cacheMisses;
        return total > 0 ? (double) cacheHits / total : 0.0;
    }
}

// Неэффективный алгоритм дедупликации O(n²)
public List<Record> deduplicateNaive(List<Record> records) {
    List<Record> unique = new ArrayList<>();
    for (Record r1 : records) {
        boolean isDuplicate = false;
        for (Record r2 : unique) {
            if (r1.equals(r2)) {
                isDuplicate = true;
                break;
            }
        }
        if (!isDuplicate) {
            unique.add(r1);
        }
    }
    return unique;
}

// Эффективный алгоритм дедупликации O(n log n)
public List<Record> deduplicateEfficient(List<Record> records) {
    if (records.isEmpty()) return Collections.emptyList();
    
    // Сортировка позволяет находить дубликаты за один проход
    List<Record> sorted = new ArrayList<>(records);
    Collections.sort(sorted);
    
    List<Record> unique = new ArrayList<>();
    Record previous = sorted.get(0);
    unique.add(previous);
    
    for (int i = 1; i < sorted.size(); i++) {
        Record current = sorted.get(i);
        if (!current.equals(previous)) {
            unique.add(current);
            previous = current;
        }
    }
    return unique;
}