import java.util.HashMap;
import java.util.Map;

public class Task041125 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        String key = "key";
        System.out.print(map.put(key, 1) + " ");
        System.out.print(map.put(key, 2) + " ");
        System.out.print(map.putIfAbsent(key, 3) + " ");
        System.out.print(map.compute(key, (k, v) -> null) + " ");
        System.out.print(map.put(key, 4));
    }
}

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  string name = 1;
  int32 age = 2;
}

public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
    @Override
    public void getUser(UserRequest request, StreamObserver<UserResponse> responseObserver) {
        UserResponse response = UserResponse.newBuilder()
            .setName("Alice")
            .setAge(30)
            .build();

        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

UserResponse response = stub.getUser(
    UserRequest.newBuilder().setId(1).build()
);
System.out.println(response.getName());

service OrderService {
  rpc ListOrders (OrdersRequest) returns (stream Order);
}

message OrdersRequest {
  string user = 1;
}

message Order {
  string id = 1;
  string product = 2;
}

public class OrderServiceImpl extends OrderServiceGrpc.OrderServiceImplBase {
    @Override
    public void listOrders(OrdersRequest request, StreamObserver<Order> responseObserver) {
        for (int i = 1; i <= 3; i++) {
            Order order = Order.newBuilder()
                .setId("ORD-" + i)
                .setProduct("Product " + i)
                .build();

            responseObserver.onNext(order);
            try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
        }
        responseObserver.onCompleted();
    }
}

stub.listOrders(OrdersRequest.newBuilder().setUser("Bob").build())
    .forEachRemaining(order -> System.out.println(order.getProduct()));

service UploadService {
  rpc UploadPhotos (stream PhotoChunk) returns (UploadStatus);
}

message PhotoChunk {
  bytes content = 1;
}

message UploadStatus {
  string message = 1;
}

public class UploadServiceImpl extends UploadServiceGrpc.UploadServiceImplBase {
    @Override
    public StreamObserver<PhotoChunk> uploadPhotos(StreamObserver<UploadStatus> responseObserver) {
        return new StreamObserver<PhotoChunk>() {
            int totalBytes = 0;

            @Override
            public void onNext(PhotoChunk chunk) {
                totalBytes += chunk.getContent().size();
            }

            @Override
            public void onError(Throwable t) {
                System.err.println("Upload failed: " + t.getMessage());
            }

            @Override
            public void onCompleted() {
                UploadStatus status = UploadStatus.newBuilder()
                    .setMessage("Uploaded " + totalBytes + " bytes")
                    .build();
                responseObserver.onNext(status);
                responseObserver.onCompleted();
            }
        };
    }
}

StreamObserver<PhotoChunk> requestObserver = asyncStub.uploadPhotos(
    new StreamObserver<UploadStatus>() {
        @Override
        public void onNext(UploadStatus status) {
            System.out.println(status.getMessage());
        }
        @Override
        public void onError(Throwable t) {}
        @Override
        public void onCompleted() {}
    }
);

// Отправляем несколько чанков
requestObserver.onNext(PhotoChunk.newBuilder().setContent(ByteString.copyFrom(new byte[1000])).build());
requestObserver.onNext(PhotoChunk.newBuilder().setContent(ByteString.copyFrom(new byte[500])).build());
requestObserver.onCompleted();

service ChatService {
  rpc Chat (stream ChatMessage) returns (stream ChatMessage);
}

message ChatMessage {
  string user = 1;
  string text = 2;
}

public class ChatServiceImpl extends ChatServiceGrpc.ChatServiceImplBase {
    @Override
    public StreamObserver<ChatMessage> chat(StreamObserver<ChatMessage> responseObserver) {
        return new StreamObserver<ChatMessage>() {
            @Override
            public void onNext(ChatMessage message) {
                // Эхо-сообщение обратно клиенту
                ChatMessage reply = ChatMessage.newBuilder()
                    .setUser("Server")
                    .setText("Echo: " + message.getText())
                    .build();
                responseObserver.onNext(reply);
            }

            @Override
            public void onError(Throwable t) {
                System.err.println("Error: " + t.getMessage());
            }

            @Override
            public void onCompleted() {
                responseObserver.onCompleted();
            }
        };
    }
}

StreamObserver<ChatMessage> requestObserver = asyncStub.chat(
    new StreamObserver<ChatMessage>() {
        @Override
        public void onNext(ChatMessage value) {
            System.out.println(value.getUser() + ": " + value.getText());
        }
        @Override
        public void onError(Throwable t) {}
        @Override
        public void onCompleted() {}
    }
);

requestObserver.onNext(ChatMessage.newBuilder().setUser("Client").setText("Hello!").build());
requestObserver.onNext(ChatMessage.newBuilder().setUser("Client").setText("How are you?").build());
requestObserver.onCompleted();

import java.util.TreeMap;

public class Task061125 {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(1, "one");
        map.put(3, "three");
        map.put(5, "five");
        map.put(7, "seven");
        
        System.out.print(map.lowerKey(4) + " ");
        System.out.print(map.floorKey(4) + " ");
        System.out.print(map.higherKey(4) + " ");
        System.out.print(map.ceilingKey(4));
    }
}