/*
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.cloud.api.servicemanagement.v1;

import com.google.api.Service;
import com.google.api.core.BetaApi;
import com.google.api.servicemanagement.v1.CreateServiceConfigRequest;
import com.google.api.servicemanagement.v1.CreateServiceRequest;
import com.google.api.servicemanagement.v1.CreateServiceRolloutRequest;
import com.google.api.servicemanagement.v1.DeleteServiceRequest;
import com.google.api.servicemanagement.v1.GenerateConfigReportRequest;
import com.google.api.servicemanagement.v1.GenerateConfigReportResponse;
import com.google.api.servicemanagement.v1.GetServiceConfigRequest;
import com.google.api.servicemanagement.v1.GetServiceRequest;
import com.google.api.servicemanagement.v1.GetServiceRolloutRequest;
import com.google.api.servicemanagement.v1.ListServiceConfigsRequest;
import com.google.api.servicemanagement.v1.ListServiceConfigsResponse;
import com.google.api.servicemanagement.v1.ListServiceRolloutsRequest;
import com.google.api.servicemanagement.v1.ListServiceRolloutsResponse;
import com.google.api.servicemanagement.v1.ListServicesRequest;
import com.google.api.servicemanagement.v1.ListServicesResponse;
import com.google.api.servicemanagement.v1.ManagedService;
import com.google.api.servicemanagement.v1.Rollout;
import com.google.api.servicemanagement.v1.ServiceManagerGrpc.ServiceManagerImplBase;
import com.google.api.servicemanagement.v1.SubmitConfigSourceRequest;
import com.google.api.servicemanagement.v1.UndeleteServiceRequest;
import com.google.longrunning.Operation;
import com.google.protobuf.AbstractMessage;
import io.grpc.stub.StreamObserver;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import javax.annotation.Generated;

@BetaApi
@Generated("by gapic-generator-java")
public class MockServiceManagerImpl extends ServiceManagerImplBase {
  private List<AbstractMessage> requests;
  private Queue<Object> responses;

  public MockServiceManagerImpl() {
    requests = new ArrayList<>();
    responses = new LinkedList<>();
  }

  public List<AbstractMessage> getRequests() {
    return requests;
  }

  public void addResponse(AbstractMessage response) {
    responses.add(response);
  }

  public void setResponses(List<AbstractMessage> responses) {
    this.responses = new LinkedList<Object>(responses);
  }

  public void addException(Exception exception) {
    responses.add(exception);
  }

  public void reset() {
    requests = new ArrayList<>();
    responses = new LinkedList<>();
  }

  @Override
  public void listServices(
      ListServicesRequest request, StreamObserver<ListServicesResponse> responseObserver) {
    Object response = responses.poll();
    if (response instanceof ListServicesResponse) {
      requests.add(request);
      responseObserver.onNext(((ListServicesResponse) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method ListServices, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  ListServicesResponse.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void getService(
      GetServiceRequest request, StreamObserver<ManagedService> responseObserver) {
    Object response = responses.poll();
    if (response instanceof ManagedService) {
      requests.add(request);
      responseObserver.onNext(((ManagedService) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method GetService, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  ManagedService.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void createService(
      CreateServiceRequest request, StreamObserver<Operation> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Operation) {
      requests.add(request);
      responseObserver.onNext(((Operation) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method CreateService, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Operation.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void deleteService(
      DeleteServiceRequest request, StreamObserver<Operation> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Operation) {
      requests.add(request);
      responseObserver.onNext(((Operation) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method DeleteService, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Operation.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void undeleteService(
      UndeleteServiceRequest request, StreamObserver<Operation> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Operation) {
      requests.add(request);
      responseObserver.onNext(((Operation) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method UndeleteService, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Operation.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void listServiceConfigs(
      ListServiceConfigsRequest request,
      StreamObserver<ListServiceConfigsResponse> responseObserver) {
    Object response = responses.poll();
    if (response instanceof ListServiceConfigsResponse) {
      requests.add(request);
      responseObserver.onNext(((ListServiceConfigsResponse) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method ListServiceConfigs, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  ListServiceConfigsResponse.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void getServiceConfig(
      GetServiceConfigRequest request, StreamObserver<Service> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Service) {
      requests.add(request);
      responseObserver.onNext(((Service) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method GetServiceConfig, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Service.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void createServiceConfig(
      CreateServiceConfigRequest request, StreamObserver<Service> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Service) {
      requests.add(request);
      responseObserver.onNext(((Service) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method CreateServiceConfig, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Service.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void submitConfigSource(
      SubmitConfigSourceRequest request, StreamObserver<Operation> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Operation) {
      requests.add(request);
      responseObserver.onNext(((Operation) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method SubmitConfigSource, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Operation.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void listServiceRollouts(
      ListServiceRolloutsRequest request,
      StreamObserver<ListServiceRolloutsResponse> responseObserver) {
    Object response = responses.poll();
    if (response instanceof ListServiceRolloutsResponse) {
      requests.add(request);
      responseObserver.onNext(((ListServiceRolloutsResponse) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method ListServiceRollouts, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  ListServiceRolloutsResponse.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void getServiceRollout(
      GetServiceRolloutRequest request, StreamObserver<Rollout> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Rollout) {
      requests.add(request);
      responseObserver.onNext(((Rollout) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method GetServiceRollout, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Rollout.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void createServiceRollout(
      CreateServiceRolloutRequest request, StreamObserver<Operation> responseObserver) {
    Object response = responses.poll();
    if (response instanceof Operation) {
      requests.add(request);
      responseObserver.onNext(((Operation) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method CreateServiceRollout, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  Operation.class.getName(),
                  Exception.class.getName())));
    }
  }

  @Override
  public void generateConfigReport(
      GenerateConfigReportRequest request,
      StreamObserver<GenerateConfigReportResponse> responseObserver) {
    Object response = responses.poll();
    if (response instanceof GenerateConfigReportResponse) {
      requests.add(request);
      responseObserver.onNext(((GenerateConfigReportResponse) response));
      responseObserver.onCompleted();
    } else if (response instanceof Exception) {
      responseObserver.onError(((Exception) response));
    } else {
      responseObserver.onError(
          new IllegalArgumentException(
              String.format(
                  "Unrecognized response type %s for method GenerateConfigReport, expected %s or %s",
                  response == null ? "null" : response.getClass().getName(),
                  GenerateConfigReportResponse.class.getName(),
                  Exception.class.getName())));
    }
  }
}