package software.amazon.vpclattice.rule;

import org.junit.jupiter.params.provider.Arguments;
import org.mockito.Mock;
import software.amazon.awssdk.services.vpclattice.VpcLatticeClient;
import software.amazon.awssdk.services.vpclattice.model.AccessDeniedException;
import software.amazon.awssdk.services.vpclattice.model.ConflictException;
import software.amazon.awssdk.services.vpclattice.model.CreateRuleRequest;
import software.amazon.awssdk.services.vpclattice.model.CreateRuleResponse;
import software.amazon.awssdk.services.vpclattice.model.DeleteRuleRequest;
import software.amazon.awssdk.services.vpclattice.model.DeleteRuleResponse;
import software.amazon.awssdk.services.vpclattice.model.GetRuleRequest;
import software.amazon.awssdk.services.vpclattice.model.GetRuleResponse;
import software.amazon.awssdk.services.vpclattice.model.InternalServerException;
import software.amazon.awssdk.services.vpclattice.model.ListRulesRequest;
import software.amazon.awssdk.services.vpclattice.model.ListRulesResponse;
import software.amazon.awssdk.services.vpclattice.model.ServiceQuotaExceededException;
import software.amazon.awssdk.services.vpclattice.model.ThrottlingException;
import software.amazon.awssdk.services.vpclattice.model.UpdateRuleRequest;
import software.amazon.awssdk.services.vpclattice.model.UpdateRuleResponse;
import software.amazon.awssdk.services.vpclattice.model.ValidationException;
import software.amazon.cloudformation.proxy.AmazonWebServicesClientProxy;
import software.amazon.cloudformation.proxy.Credentials;
import software.amazon.cloudformation.proxy.HandlerErrorCode;
import software.amazon.cloudformation.proxy.LoggerProxy;
import software.amazon.cloudformation.proxy.ProxyClient;

import javax.annotation.Nonnull;
import java.util.stream.Stream;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;

public abstract class BaseTest {
    protected AmazonWebServicesClientProxy proxy;

    @Mock
    protected software.amazon.awssdk.services.vpclattice.VpcLatticeClient client;

    @Mock
    protected ProxyClient<VpcLatticeClient> proxyClient;

    protected BaseHandlerStd handler;

    protected static final LoggerProxy logger;

    protected static final Credentials MOCK_CREDENTIALS;

    static {
        MOCK_CREDENTIALS = new Credentials("accessKey", "secretKey", "token");
        logger = new LoggerProxy();
    }

    public static final String AWS_ACCOUNT_ID = "123456789012";

    public static final String REGION = "us-west-2";

    public static final String SERVICE_ID = "svc-12345678901234567";

    public static final String LISTENER_ID = "listener-12345678901234567";

    public static final String RULE_ID = "rule-12345678901234567";

    public static final String RULE_ARN = String.format(
            "arn:aws:vpc-lattice:%s:%s:service/%s/listener/%s/rule/%s",
            REGION,
            AWS_ACCOUNT_ID,
            SERVICE_ID,
            LISTENER_ID,
            RULE_ID
    );

    public static final String CLIENT_TOKEN = "DUMMY_TOKEN";

    public static final String RULE_NAME = "rule-name";

    public static final Integer RULE_PRIORITY = 50;

    public static final String NEXT_TOKEN = "DUMMY_TOKEN";

    public static final software.amazon.awssdk.services.vpclattice.model.RuleMatch RULE_MATCH =
            software.amazon.awssdk.services.vpclattice.model.RuleMatch.builder().build();

    public static final software.amazon.awssdk.services.vpclattice.model.RuleAction RULE_ACTION =
            software.amazon.awssdk.services.vpclattice.model.RuleAction.builder().build();

    public static final Match MODEL_RULE_MATCH = Match.builder()
            .httpMatch(HttpMatch.builder().method("foo").build())
            .build();

    public static final Match UPDATED_MODEL_RULE_MATCH = Match.builder()
            .httpMatch(HttpMatch.builder().method("bar").build())
            .build();

    public static final Action MODEL_RULE_ACTION = Action.builder().build();

    protected GetRuleResponse getRule(final int priortiy) {
        return GetRuleResponse.builder()
                .id(RULE_ID)
                .arn(RULE_ARN)
                .name(RULE_NAME)
                .isDefault(false)
                .match(RULE_MATCH)
                .priority(priortiy)
                .action(RULE_ACTION)
                .build();
    }

    public static Stream<Arguments> provideExceptions() {
        return Stream.of(
                Arguments.of(ValidationException.class, HandlerErrorCode.InvalidRequest),
                Arguments.of(ConflictException.class, HandlerErrorCode.InvalidRequest),
                Arguments.of(AccessDeniedException.class, HandlerErrorCode.AccessDenied),
                Arguments.of(InternalServerException.class, HandlerErrorCode.ServiceInternalError),
                Arguments.of(ServiceQuotaExceededException.class, HandlerErrorCode.ServiceLimitExceeded),
                Arguments.of(ThrottlingException.class, HandlerErrorCode.Throttling),
                Arguments.of(IllegalStateException.class, HandlerErrorCode.InternalFailure)
        );
    }

    protected void mockProxyClient() {
        doReturn(proxyClient).when(proxy).newProxy(any());
    }

    protected void mockSdkReturn(@Nonnull final UpdateRuleResponse response) {
        doReturn(response).when(proxyClient.client()).updateRule(any(UpdateRuleRequest.class));
    }

    protected void mockSdkReturn(@Nonnull final GetRuleResponse response, @Nonnull final GetRuleResponse... responses) {
        var stubber = doReturn(response);

        for (final var r : responses) {
            stubber = stubber.doReturn(r);
        }

        stubber.when(proxyClient.client()).getRule(any(GetRuleRequest.class));
    }

    protected void mockSdkReturn(@Nonnull final CreateRuleResponse response) {
        doReturn(response).when(proxyClient.client()).createRule(any(CreateRuleRequest.class));
    }

    protected void mockSdkReturn(@Nonnull final DeleteRuleResponse response) {
        doReturn(response).when(proxyClient.client()).deleteRule(any(DeleteRuleRequest.class));
    }

    protected void mockSdkReturn(@Nonnull final ListRulesResponse response) {
        doReturn(response).when(proxyClient.client()).listRules(any(ListRulesRequest.class));
    }

    protected void mockSdkGetThrow(@Nonnull final Class<? extends Throwable> exception) {
        doThrow(exception).when(proxyClient.client()).getRule(any(GetRuleRequest.class));
    }

    protected void mockSdkCreateThrow(@Nonnull final Class<? extends Throwable> exception) {
        doThrow(exception).when(proxyClient.client()).createRule(any(CreateRuleRequest.class));
    }

    protected void mockSdkCreateThrow(@Nonnull final Throwable exception) {
        doThrow(exception).when(proxyClient.client()).createRule(any(CreateRuleRequest.class));
    }

    protected void mockSdkUpdateThrow(@Nonnull final Class<? extends Throwable> exception) {
        doThrow(exception).when(proxyClient.client()).updateRule(any(UpdateRuleRequest.class));
    }

    protected void mockSdkDeleteThrow(@Nonnull final Class<? extends Throwable> exception) {
        doThrow(exception).when(proxyClient.client()).deleteRule(any(DeleteRuleRequest.class));
    }

    protected void mockSdkListThrow(@Nonnull final Class<? extends Throwable> exception) {
        doThrow(exception).when(proxyClient.client()).listRules(any(ListRulesRequest.class));
    }
}