//
// Copyright Amazon.com Inc. or its affiliates.
// All Rights Reserved.
//
// SPDX-License-Identifier: Apache-2.0
//

import AWSPinpoint
import Foundation

class MockPinpointClient: PinpointClientProtocol {
    func createApp(input: CreateAppInput) async throws -> CreateAppOutputResponse {
        fatalError("Not supported")
    }

    func createCampaign(input: CreateCampaignInput) async throws -> CreateCampaignOutputResponse {
        fatalError("Not supported")
    }

    func createEmailTemplate(input: CreateEmailTemplateInput) async throws -> CreateEmailTemplateOutputResponse {
        fatalError("Not supported")
    }

    func createExportJob(input: CreateExportJobInput) async throws -> CreateExportJobOutputResponse {
        fatalError("Not supported")
    }

    func createImportJob(input: CreateImportJobInput) async throws -> CreateImportJobOutputResponse {
        fatalError("Not supported")
    }

    func createInAppTemplate(input: CreateInAppTemplateInput) async throws -> CreateInAppTemplateOutputResponse {
        fatalError("Not supported")
    }

    func createJourney(input: CreateJourneyInput) async throws -> CreateJourneyOutputResponse {
        fatalError("Not supported")
    }

    func createPushTemplate(input: CreatePushTemplateInput) async throws -> CreatePushTemplateOutputResponse {
        fatalError("Not supported")
    }

    func createRecommenderConfiguration(input: CreateRecommenderConfigurationInput) async throws -> CreateRecommenderConfigurationOutputResponse {
        fatalError("Not supported")
    }

    func createSegment(input: CreateSegmentInput) async throws -> CreateSegmentOutputResponse {
        fatalError("Not supported")
    }

    func createSmsTemplate(input: CreateSmsTemplateInput) async throws -> CreateSmsTemplateOutputResponse {
        fatalError("Not supported")
    }

    func createVoiceTemplate(input: CreateVoiceTemplateInput) async throws -> CreateVoiceTemplateOutputResponse {
        fatalError("Not supported")
    }

    func deleteAdmChannel(input: DeleteAdmChannelInput) async throws -> DeleteAdmChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteApnsChannel(input: DeleteApnsChannelInput) async throws -> DeleteApnsChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteApnsSandboxChannel(input: DeleteApnsSandboxChannelInput) async throws -> DeleteApnsSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteApnsVoipChannel(input: DeleteApnsVoipChannelInput) async throws -> DeleteApnsVoipChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteApnsVoipSandboxChannel(input: DeleteApnsVoipSandboxChannelInput) async throws -> DeleteApnsVoipSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteApp(input: DeleteAppInput) async throws -> DeleteAppOutputResponse {
        fatalError("Not supported")
    }

    func deleteBaiduChannel(input: DeleteBaiduChannelInput) async throws -> DeleteBaiduChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteCampaign(input: DeleteCampaignInput) async throws -> DeleteCampaignOutputResponse {
        fatalError("Not supported")
    }

    func deleteEmailChannel(input: DeleteEmailChannelInput) async throws -> DeleteEmailChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteEmailTemplate(input: DeleteEmailTemplateInput) async throws -> DeleteEmailTemplateOutputResponse {
        fatalError("Not supported")
    }

    func deleteEndpoint(input: DeleteEndpointInput) async throws -> DeleteEndpointOutputResponse {
        fatalError("Not supported")
    }

    func deleteEventStream(input: DeleteEventStreamInput) async throws -> DeleteEventStreamOutputResponse {
        fatalError("Not supported")
    }

    func deleteGcmChannel(input: DeleteGcmChannelInput) async throws -> DeleteGcmChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteInAppTemplate(input: DeleteInAppTemplateInput) async throws -> DeleteInAppTemplateOutputResponse {
        fatalError("Not supported")
    }

    func deleteJourney(input: DeleteJourneyInput) async throws -> DeleteJourneyOutputResponse {
        fatalError("Not supported")
    }

    func deletePushTemplate(input: DeletePushTemplateInput) async throws -> DeletePushTemplateOutputResponse {
        fatalError("Not supported")
    }

    func deleteRecommenderConfiguration(input: DeleteRecommenderConfigurationInput) async throws -> DeleteRecommenderConfigurationOutputResponse {
        fatalError("Not supported")
    }

    func deleteSegment(input: DeleteSegmentInput) async throws -> DeleteSegmentOutputResponse {
        fatalError("Not supported")
    }

    func deleteSmsChannel(input: DeleteSmsChannelInput) async throws -> DeleteSmsChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteSmsTemplate(input: DeleteSmsTemplateInput) async throws -> DeleteSmsTemplateOutputResponse {
        fatalError("Not supported")
    }

    func deleteUserEndpoints(input: DeleteUserEndpointsInput) async throws -> DeleteUserEndpointsOutputResponse {
        fatalError("Not supported")
    }

    func deleteVoiceChannel(input: DeleteVoiceChannelInput) async throws -> DeleteVoiceChannelOutputResponse {
        fatalError("Not supported")
    }

    func deleteVoiceTemplate(input: DeleteVoiceTemplateInput) async throws -> DeleteVoiceTemplateOutputResponse {
        fatalError("Not supported")
    }

    func getAdmChannel(input: GetAdmChannelInput) async throws -> GetAdmChannelOutputResponse {
        fatalError("Not supported")
    }

    func getApnsChannel(input: GetApnsChannelInput) async throws -> GetApnsChannelOutputResponse {
        fatalError("Not supported")
    }

    func getApnsSandboxChannel(input: GetApnsSandboxChannelInput) async throws -> GetApnsSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func getApnsVoipChannel(input: GetApnsVoipChannelInput) async throws -> GetApnsVoipChannelOutputResponse {
        fatalError("Not supported")
    }

    func getApnsVoipSandboxChannel(input: GetApnsVoipSandboxChannelInput) async throws -> GetApnsVoipSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func getApp(input: GetAppInput) async throws -> GetAppOutputResponse {
        fatalError("Not supported")
    }

    func getApplicationDateRangeKpi(input: GetApplicationDateRangeKpiInput) async throws -> GetApplicationDateRangeKpiOutputResponse {
        fatalError("Not supported")
    }

    func getApplicationSettings(input: GetApplicationSettingsInput) async throws -> GetApplicationSettingsOutputResponse {
        fatalError("Not supported")
    }

    func getApps(input: GetAppsInput) async throws -> GetAppsOutputResponse {
        fatalError("Not supported")
    }

    func getBaiduChannel(input: GetBaiduChannelInput) async throws -> GetBaiduChannelOutputResponse {
        fatalError("Not supported")
    }

    func getCampaign(input: GetCampaignInput) async throws -> GetCampaignOutputResponse {
        fatalError("Not supported")
    }

    func getCampaignActivities(input: GetCampaignActivitiesInput) async throws -> GetCampaignActivitiesOutputResponse {
        fatalError("Not supported")
    }

    func getCampaignDateRangeKpi(input: GetCampaignDateRangeKpiInput) async throws -> GetCampaignDateRangeKpiOutputResponse {
        fatalError("Not supported")
    }

    func getCampaigns(input: GetCampaignsInput) async throws -> GetCampaignsOutputResponse {
        fatalError("Not supported")
    }

    func getCampaignVersion(input: GetCampaignVersionInput) async throws -> GetCampaignVersionOutputResponse {
        fatalError("Not supported")
    }

    func getCampaignVersions(input: GetCampaignVersionsInput) async throws -> GetCampaignVersionsOutputResponse {
        fatalError("Not supported")
    }

    func getChannels(input: GetChannelsInput) async throws -> GetChannelsOutputResponse {
        fatalError("Not supported")
    }

    func getEmailChannel(input: GetEmailChannelInput) async throws -> GetEmailChannelOutputResponse {
        fatalError("Not supported")
    }

    func getEmailTemplate(input: GetEmailTemplateInput) async throws -> GetEmailTemplateOutputResponse {
        fatalError("Not supported")
    }

    func getEndpoint(input: GetEndpointInput) async throws -> GetEndpointOutputResponse {
        fatalError("Not supported")
    }

    func getEventStream(input: GetEventStreamInput) async throws -> GetEventStreamOutputResponse {
        fatalError("Not supported")
    }

    func getExportJob(input: GetExportJobInput) async throws -> GetExportJobOutputResponse {
        fatalError("Not supported")
    }

    func getExportJobs(input: GetExportJobsInput) async throws -> GetExportJobsOutputResponse {
        fatalError("Not supported")
    }

    func getGcmChannel(input: GetGcmChannelInput) async throws -> GetGcmChannelOutputResponse {
        fatalError("Not supported")
    }

    func getImportJob(input: GetImportJobInput) async throws -> GetImportJobOutputResponse {
        fatalError("Not supported")
    }

    func getImportJobs(input: GetImportJobsInput) async throws -> GetImportJobsOutputResponse {
        fatalError("Not supported")
    }

    func getInAppMessages(input: GetInAppMessagesInput) async throws -> GetInAppMessagesOutputResponse {
        fatalError("Not supported")
    }

    func getInAppTemplate(input: GetInAppTemplateInput) async throws -> GetInAppTemplateOutputResponse {
        fatalError("Not supported")
    }

    func getJourney(input: GetJourneyInput) async throws -> GetJourneyOutputResponse {
        fatalError("Not supported")
    }

    func getJourneyDateRangeKpi(input: GetJourneyDateRangeKpiInput) async throws -> GetJourneyDateRangeKpiOutputResponse {
        fatalError("Not supported")
    }

    func getJourneyExecutionActivityMetrics(input: GetJourneyExecutionActivityMetricsInput) async throws -> GetJourneyExecutionActivityMetricsOutputResponse {
        fatalError("Not supported")
    }

    func getJourneyExecutionMetrics(input: GetJourneyExecutionMetricsInput) async throws -> GetJourneyExecutionMetricsOutputResponse {
        fatalError("Not supported")
    }

    func getPushTemplate(input: GetPushTemplateInput) async throws -> GetPushTemplateOutputResponse {
        fatalError("Not supported")
    }

    func getRecommenderConfiguration(input: GetRecommenderConfigurationInput) async throws -> GetRecommenderConfigurationOutputResponse {
        fatalError("Not supported")
    }

    func getRecommenderConfigurations(input: GetRecommenderConfigurationsInput) async throws -> GetRecommenderConfigurationsOutputResponse {
        fatalError("Not supported")
    }

    func getSegment(input: GetSegmentInput) async throws -> GetSegmentOutputResponse {
        fatalError("Not supported")
    }

    func getSegmentExportJobs(input: GetSegmentExportJobsInput) async throws -> GetSegmentExportJobsOutputResponse {
        fatalError("Not supported")
    }

    func getSegmentImportJobs(input: GetSegmentImportJobsInput) async throws -> GetSegmentImportJobsOutputResponse {
        fatalError("Not supported")
    }

    func getSegments(input: GetSegmentsInput) async throws -> GetSegmentsOutputResponse {
        fatalError("Not supported")
    }

    func getSegmentVersion(input: GetSegmentVersionInput) async throws -> GetSegmentVersionOutputResponse {
        fatalError("Not supported")
    }

    func getSegmentVersions(input: GetSegmentVersionsInput) async throws -> GetSegmentVersionsOutputResponse {
        fatalError("Not supported")
    }

    func getSmsChannel(input: GetSmsChannelInput) async throws -> GetSmsChannelOutputResponse {
        fatalError("Not supported")
    }

    func getSmsTemplate(input: GetSmsTemplateInput) async throws -> GetSmsTemplateOutputResponse {
        fatalError("Not supported")
    }

    func getUserEndpoints(input: GetUserEndpointsInput) async throws -> GetUserEndpointsOutputResponse {
        fatalError("Not supported")
    }

    func getVoiceChannel(input: GetVoiceChannelInput) async throws -> GetVoiceChannelOutputResponse {
        fatalError("Not supported")
    }

    func getVoiceTemplate(input: GetVoiceTemplateInput) async throws -> GetVoiceTemplateOutputResponse {
        fatalError("Not supported")
    }

    func listJourneys(input: ListJourneysInput) async throws -> ListJourneysOutputResponse {
        fatalError("Not supported")
    }

    func listTagsForResource(input: ListTagsForResourceInput) async throws -> ListTagsForResourceOutputResponse {
        fatalError("Not supported")
    }

    func listTemplates(input: ListTemplatesInput) async throws -> ListTemplatesOutputResponse {
        fatalError("Not supported")
    }

    func listTemplateVersions(input: ListTemplateVersionsInput) async throws -> ListTemplateVersionsOutputResponse {
        fatalError("Not supported")
    }

    func phoneNumberValidate(input: PhoneNumberValidateInput) async throws -> PhoneNumberValidateOutputResponse {
        fatalError("Not supported")
    }

    func putEvents(input: PutEventsInput) async throws -> PutEventsOutputResponse {
        fatalError("Not supported")
    }

    func putEventStream(input: PutEventStreamInput) async throws -> PutEventStreamOutputResponse {
        fatalError("Not supported")
    }

    func removeAttributes(input: RemoveAttributesInput) async throws -> RemoveAttributesOutputResponse {
        fatalError("Not supported")
    }

    func sendMessages(input: SendMessagesInput) async throws -> SendMessagesOutputResponse {
        fatalError("Not supported")
    }

    func sendOTPMessage(input: SendOTPMessageInput) async throws -> SendOTPMessageOutputResponse {
        fatalError("Not supported")
    }

    func sendUsersMessages(input: SendUsersMessagesInput) async throws -> SendUsersMessagesOutputResponse {
        fatalError("Not supported")
    }

    func tagResource(input: TagResourceInput) async throws -> TagResourceOutputResponse {
        fatalError("Not supported")
    }

    func untagResource(input: UntagResourceInput) async throws -> UntagResourceOutputResponse {
        fatalError("Not supported")
    }

    func updateAdmChannel(input: UpdateAdmChannelInput) async throws -> UpdateAdmChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateApnsChannel(input: UpdateApnsChannelInput) async throws -> UpdateApnsChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateApnsSandboxChannel(input: UpdateApnsSandboxChannelInput) async throws -> UpdateApnsSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateApnsVoipChannel(input: UpdateApnsVoipChannelInput) async throws -> UpdateApnsVoipChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateApnsVoipSandboxChannel(input: UpdateApnsVoipSandboxChannelInput) async throws -> UpdateApnsVoipSandboxChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateApplicationSettings(input: UpdateApplicationSettingsInput) async throws -> UpdateApplicationSettingsOutputResponse {
        fatalError("Not supported")
    }

    func updateBaiduChannel(input: UpdateBaiduChannelInput) async throws -> UpdateBaiduChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateCampaign(input: UpdateCampaignInput) async throws -> UpdateCampaignOutputResponse {
        fatalError("Not supported")
    }

    func updateEmailChannel(input: UpdateEmailChannelInput) async throws -> UpdateEmailChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateEmailTemplate(input: UpdateEmailTemplateInput) async throws -> UpdateEmailTemplateOutputResponse {
        fatalError("Not supported")
    }

    var updateEndpointCount = 0
    var updateEndpointResult: Result<UpdateEndpointOutputResponse, Error>?
    func updateEndpoint(input: UpdateEndpointInput) async throws -> UpdateEndpointOutputResponse {
        updateEndpointCount += 1
        guard let result = updateEndpointResult else {
            return UpdateEndpointOutputResponse()
        }

        switch result {
        case .success(let output):
            return output
        case .failure(let error):
            throw error
        }
    }

    func updateEndpointsBatch(input: UpdateEndpointsBatchInput) async throws -> UpdateEndpointsBatchOutputResponse {
        fatalError("Not supported")
    }

    func updateGcmChannel(input: UpdateGcmChannelInput) async throws -> UpdateGcmChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateInAppTemplate(input: UpdateInAppTemplateInput) async throws -> UpdateInAppTemplateOutputResponse {
        fatalError("Not supported")
    }

    func updateJourney(input: UpdateJourneyInput) async throws -> UpdateJourneyOutputResponse {
        fatalError("Not supported")
    }

    func updateJourneyState(input: UpdateJourneyStateInput) async throws -> UpdateJourneyStateOutputResponse {
        fatalError("Not supported")
    }

    func updatePushTemplate(input: UpdatePushTemplateInput) async throws -> UpdatePushTemplateOutputResponse {
        fatalError("Not supported")
    }

    func updateRecommenderConfiguration(input: UpdateRecommenderConfigurationInput) async throws -> UpdateRecommenderConfigurationOutputResponse {
        fatalError("Not supported")
    }

    func updateSegment(input: UpdateSegmentInput) async throws -> UpdateSegmentOutputResponse {
        fatalError("Not supported")
    }

    func updateSmsChannel(input: UpdateSmsChannelInput) async throws -> UpdateSmsChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateSmsTemplate(input: UpdateSmsTemplateInput) async throws -> UpdateSmsTemplateOutputResponse {
        fatalError("Not supported")
    }

    func updateTemplateActiveVersion(input: UpdateTemplateActiveVersionInput) async throws -> UpdateTemplateActiveVersionOutputResponse {
        fatalError("Not supported")
    }

    func updateVoiceChannel(input: UpdateVoiceChannelInput) async throws -> UpdateVoiceChannelOutputResponse {
        fatalError("Not supported")
    }

    func updateVoiceTemplate(input: UpdateVoiceTemplateInput) async throws -> UpdateVoiceTemplateOutputResponse {
        fatalError("Not supported")
    }

    func verifyOTPMessage(input: VerifyOTPMessageInput) async throws -> VerifyOTPMessageOutputResponse {
        fatalError("Not supported")
    }
}