// Copyright 2023 Cisco Systems, Inc. and/or its affiliates
//
// 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
//
//     http://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.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/scale/types.go

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"

	api "github.com/banzaicloud/go-cruise-control/pkg/api"
	types "github.com/banzaicloud/go-cruise-control/pkg/types"
	scale "github.com/banzaicloud/koperator/pkg/scale"
	gomock "go.uber.org/mock/gomock"
)

// MockCruiseControlScaler is a mock of CruiseControlScaler interface.
type MockCruiseControlScaler struct {
	ctrl     *gomock.Controller
	recorder *MockCruiseControlScalerMockRecorder
}

// MockCruiseControlScalerMockRecorder is the mock recorder for MockCruiseControlScaler.
type MockCruiseControlScalerMockRecorder struct {
	mock *MockCruiseControlScaler
}

// NewMockCruiseControlScaler creates a new mock instance.
func NewMockCruiseControlScaler(ctrl *gomock.Controller) *MockCruiseControlScaler {
	mock := &MockCruiseControlScaler{ctrl: ctrl}
	mock.recorder = &MockCruiseControlScalerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCruiseControlScaler) EXPECT() *MockCruiseControlScalerMockRecorder {
	return m.recorder
}

// AddBrokers mocks base method.
func (m *MockCruiseControlScaler) AddBrokers(ctx context.Context, brokerIDs ...string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range brokerIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddBrokers", varargs...)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddBrokers indicates an expected call of AddBrokers.
func (mr *MockCruiseControlScalerMockRecorder) AddBrokers(ctx interface{}, brokerIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, brokerIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBrokers", reflect.TypeOf((*MockCruiseControlScaler)(nil).AddBrokers), varargs...)
}

// AddBrokersWithParams mocks base method.
func (m *MockCruiseControlScaler) AddBrokersWithParams(ctx context.Context, params map[string]string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBrokersWithParams", ctx, params)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddBrokersWithParams indicates an expected call of AddBrokersWithParams.
func (mr *MockCruiseControlScalerMockRecorder) AddBrokersWithParams(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBrokersWithParams", reflect.TypeOf((*MockCruiseControlScaler)(nil).AddBrokersWithParams), ctx, params)
}

// BrokerWithLeastPartitionReplicas mocks base method.
func (m *MockCruiseControlScaler) BrokerWithLeastPartitionReplicas(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BrokerWithLeastPartitionReplicas", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BrokerWithLeastPartitionReplicas indicates an expected call of BrokerWithLeastPartitionReplicas.
func (mr *MockCruiseControlScalerMockRecorder) BrokerWithLeastPartitionReplicas(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BrokerWithLeastPartitionReplicas", reflect.TypeOf((*MockCruiseControlScaler)(nil).BrokerWithLeastPartitionReplicas), ctx)
}

// BrokersWithState mocks base method.
func (m *MockCruiseControlScaler) BrokersWithState(ctx context.Context, states ...scale.KafkaBrokerState) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range states {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BrokersWithState", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BrokersWithState indicates an expected call of BrokersWithState.
func (mr *MockCruiseControlScalerMockRecorder) BrokersWithState(ctx interface{}, states ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, states...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BrokersWithState", reflect.TypeOf((*MockCruiseControlScaler)(nil).BrokersWithState), varargs...)
}

// IsReady mocks base method.
func (m *MockCruiseControlScaler) IsReady(ctx context.Context) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsReady", ctx)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsReady indicates an expected call of IsReady.
func (mr *MockCruiseControlScalerMockRecorder) IsReady(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReady", reflect.TypeOf((*MockCruiseControlScaler)(nil).IsReady), ctx)
}

// IsUp mocks base method.
func (m *MockCruiseControlScaler) IsUp(ctx context.Context) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUp", ctx)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsUp indicates an expected call of IsUp.
func (mr *MockCruiseControlScalerMockRecorder) IsUp(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUp", reflect.TypeOf((*MockCruiseControlScaler)(nil).IsUp), ctx)
}

// KafkaClusterLoad mocks base method.
func (m *MockCruiseControlScaler) KafkaClusterLoad(ctx context.Context) (*api.KafkaClusterLoadResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KafkaClusterLoad", ctx)
	ret0, _ := ret[0].(*api.KafkaClusterLoadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KafkaClusterLoad indicates an expected call of KafkaClusterLoad.
func (mr *MockCruiseControlScalerMockRecorder) KafkaClusterLoad(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KafkaClusterLoad", reflect.TypeOf((*MockCruiseControlScaler)(nil).KafkaClusterLoad), ctx)
}

// KafkaClusterState mocks base method.
func (m *MockCruiseControlScaler) KafkaClusterState(ctx context.Context) (*types.KafkaClusterState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KafkaClusterState", ctx)
	ret0, _ := ret[0].(*types.KafkaClusterState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KafkaClusterState indicates an expected call of KafkaClusterState.
func (mr *MockCruiseControlScalerMockRecorder) KafkaClusterState(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KafkaClusterState", reflect.TypeOf((*MockCruiseControlScaler)(nil).KafkaClusterState), ctx)
}

// LogDirsByBroker mocks base method.
func (m *MockCruiseControlScaler) LogDirsByBroker(ctx context.Context) (map[string]map[scale.LogDirState][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogDirsByBroker", ctx)
	ret0, _ := ret[0].(map[string]map[scale.LogDirState][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogDirsByBroker indicates an expected call of LogDirsByBroker.
func (mr *MockCruiseControlScalerMockRecorder) LogDirsByBroker(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDirsByBroker", reflect.TypeOf((*MockCruiseControlScaler)(nil).LogDirsByBroker), ctx)
}

// PartitionReplicasByBroker mocks base method.
func (m *MockCruiseControlScaler) PartitionReplicasByBroker(ctx context.Context) (map[string]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PartitionReplicasByBroker", ctx)
	ret0, _ := ret[0].(map[string]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PartitionReplicasByBroker indicates an expected call of PartitionReplicasByBroker.
func (mr *MockCruiseControlScalerMockRecorder) PartitionReplicasByBroker(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PartitionReplicasByBroker", reflect.TypeOf((*MockCruiseControlScaler)(nil).PartitionReplicasByBroker), ctx)
}

// RebalanceDisks mocks base method.
func (m *MockCruiseControlScaler) RebalanceDisks(ctx context.Context, brokerIDs ...string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range brokerIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RebalanceDisks", varargs...)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebalanceDisks indicates an expected call of RebalanceDisks.
func (mr *MockCruiseControlScalerMockRecorder) RebalanceDisks(ctx interface{}, brokerIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, brokerIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebalanceDisks", reflect.TypeOf((*MockCruiseControlScaler)(nil).RebalanceDisks), varargs...)
}

// RebalanceWithParams mocks base method.
func (m *MockCruiseControlScaler) RebalanceWithParams(ctx context.Context, params map[string]string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebalanceWithParams", ctx, params)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebalanceWithParams indicates an expected call of RebalanceWithParams.
func (mr *MockCruiseControlScalerMockRecorder) RebalanceWithParams(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebalanceWithParams", reflect.TypeOf((*MockCruiseControlScaler)(nil).RebalanceWithParams), ctx, params)
}

// RemoveBrokers mocks base method.
func (m *MockCruiseControlScaler) RemoveBrokers(ctx context.Context, brokerIDs ...string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range brokerIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveBrokers", varargs...)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveBrokers indicates an expected call of RemoveBrokers.
func (mr *MockCruiseControlScalerMockRecorder) RemoveBrokers(ctx interface{}, brokerIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, brokerIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBrokers", reflect.TypeOf((*MockCruiseControlScaler)(nil).RemoveBrokers), varargs...)
}

// RemoveBrokersWithParams mocks base method.
func (m *MockCruiseControlScaler) RemoveBrokersWithParams(ctx context.Context, params map[string]string) (*scale.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveBrokersWithParams", ctx, params)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveBrokersWithParams indicates an expected call of RemoveBrokersWithParams.
func (mr *MockCruiseControlScalerMockRecorder) RemoveBrokersWithParams(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBrokersWithParams", reflect.TypeOf((*MockCruiseControlScaler)(nil).RemoveBrokersWithParams), ctx, params)
}

// Status mocks base method.
func (m *MockCruiseControlScaler) Status(ctx context.Context) (scale.StatusTaskResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status", ctx)
	ret0, _ := ret[0].(scale.StatusTaskResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Status indicates an expected call of Status.
func (mr *MockCruiseControlScalerMockRecorder) Status(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockCruiseControlScaler)(nil).Status), ctx)
}

// StatusTask mocks base method.
func (m *MockCruiseControlScaler) StatusTask(ctx context.Context, taskId string) (scale.StatusTaskResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatusTask", ctx, taskId)
	ret0, _ := ret[0].(scale.StatusTaskResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatusTask indicates an expected call of StatusTask.
func (mr *MockCruiseControlScalerMockRecorder) StatusTask(ctx, taskId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusTask", reflect.TypeOf((*MockCruiseControlScaler)(nil).StatusTask), ctx, taskId)
}

// StopExecution mocks base method.
func (m *MockCruiseControlScaler) StopExecution(ctx context.Context) (*scale.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopExecution", ctx)
	ret0, _ := ret[0].(*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopExecution indicates an expected call of StopExecution.
func (mr *MockCruiseControlScalerMockRecorder) StopExecution(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopExecution", reflect.TypeOf((*MockCruiseControlScaler)(nil).StopExecution), ctx)
}

// UserTasks mocks base method.
func (m *MockCruiseControlScaler) UserTasks(ctx context.Context, taskIDs ...string) ([]*scale.Result, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range taskIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UserTasks", varargs...)
	ret0, _ := ret[0].([]*scale.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UserTasks indicates an expected call of UserTasks.
func (mr *MockCruiseControlScalerMockRecorder) UserTasks(ctx interface{}, taskIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, taskIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserTasks", reflect.TypeOf((*MockCruiseControlScaler)(nil).UserTasks), varargs...)
}
