syntax = "proto3";

package proto;

service Message {
  // send message
  rpc sendMessage (MessageRequest) returns (MessageReply) {}
}
// message request
message MessageRequest {
  string message = 1;
}
// message response
message MessageReply {
  string message = 1;
  int32 code=2;
  string result=3;
  bool success=4;
}

import com.dji.sample.ai.grpc.MessageGrpc;
import com.dji.sample.ai.grpc.MessageReply;
import com.dji.sample.ai.grpc.MessageRequest;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;

import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class MessageClient {
    private static final Logger logger = Logger.getLogger(MessageClient.class.getName());

    private final ManagedChannel channel;
    private final MessageGrpc.MessageBlockingStub blockingStub;

    /**
     * Construct client connecting to HelloWorld server at {@code host:port}.
     */
    public MessageClient(String host, int port) {
        this(ManagedChannelBuilder.forAddress(host, port)
                // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
                // needing certificates.
                .usePlaintext()
                .build());
    }

    /**
     * Construct client for accessing HelloWorld server using the existing channel.
     */
    MessageClient(ManagedChannel channel) {
        this.channel = channel;
        blockingStub = MessageGrpc.newBlockingStub(channel);
    }

    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    /**
     * Say hello to server.
     */
    public void sendMessage(String message) {
        MessageRequest request = MessageRequest.newBuilder().setMessage(message).build();
        MessageReply response;
        try {
            response = blockingStub.sendMessage(request);
            logger.info("接收来自服务器的响应: " + response.getMessage());
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return;
        }

    }

    /**
     * Greet server. If provided, the first element of {@code args} is the name to use in the
     * greeting.
     */
    public static void main(String[] args) throws Exception {
        // Access a service running on the local machine on port 50052
        MessageClient client = new MessageClient("localhost", 50052);
        try {
            String user = "world";
            // Use the arg as the name to greet if provided
            if (args.length > 0) {
                user = args[0];
            }
            int i = 0 ;
            while (true){
                client.sendMessage(user+i++);
                Thread.sleep(1000);
            }
        } finally {
            client.shutdown();
        }
    }
}

@Slf4j
public class AiServer extends ManageAiGrpc.ManageAiImplBase {
    // 增加AI识别记录
    @Override
    public void addManageAi(ManageAiRequest request, StreamObserver<ManageAiResponse> responseObserver) {
        ManageAiResponse response = ManageAiResponse.newBuilder()
                .setCode(200)
                .setSuccess(true)
                .build();

        // Use responseObserver to send a single response back
        responseObserver.onNext(response);

        // When you are done, you must call onCompleted.
        responseObserver.onCompleted();
    }
}

public class App
{
    public static void main( String[] args ) throws Exception
    {
      // Create a new server to listen on port 8080
      Server server = ServerBuilder.forPort(8080)
        .addService(new GreetingServiceImpl())
        .build();

      // Start the server
      server.start();

      // Server threads are running in the background.
      System.out.println("Server started");
      // Don't exit the main thread. Wait until server is terminated.
      server.awaitTermination();
    }
}

@Slf4j
public class AiServer extends ManageAiGrpc.ManageAiImplBase {
    // 上传接口
    @Override
    public StreamObserver<FileUploadRequest> fileUpload(StreamObserver<ManageAiResponse> responseObserver){
        return new StreamObserver<FileUploadRequest>() {

            // 实现数据接收
            @Override
            public void onNext(FileUploadRequest stock) {
                log.info(stock.toString());
            }

            // 数据接收完成,返回信息
            @Override
            public void onCompleted() {
                responseObserver.onNext(ManageAiResponse.newBuilder()
                        .build());
                responseObserver.onCompleted();
            }
            // 数据接收错误
            @Override
            public void onError(Throwable t) {
                log.error(t.getMessage(), t);
            }
        };
    }

    public static void main( String[] args ) throws Exception
    {
        // Create a new server to listen on port 8080
        Server server = ServerBuilder.forPort(9999)
                .addService(new AiServer())
                .build();

        // Start the server
        server.start();

        // Server threads are running in the background.
        System.out.println("Server started");
        // Don't exit the main thread. Wait until server is terminated.
        server.awaitTermination();
    }
}

syntax = "proto3";
package shiyun;
// The greeting service definition.
service AutoChat {
  rpc autoChat (AutoChatRequest) returns (AutoChatReply) {}
}
// The request message containing the user's name.
message AutoChatRequest {
  string question = 1;
}
// The response message containing the greetings
message AutoChatReply {
  string response = 1;
}