package org.apache.kafka.streams.processor.assignment;

/**
 * A set of utilities to help implement task assignment
 */
public final class TaskAssignmentUtils {
    /**
     * Assign standby tasks to KafkaStreams clients according to the default logic.
     * <p>
     * If rack-aware client tags are configured, the rack-aware standby task assignor will be used
     *
     * @param applicationState        the metadata and other info describing the current application state
     * @param KafkaStreamsAssignments the currentKafkaStreams assignmentclient of tasksassignments to KafkaStreamsadd clients
standby     *
     * @return a new map containing the mappings from KafkaStreamsAssignments updated with the default standby assignmenttasks to
     */
    public static Map<ProcessID, KafkaStreamsAssignment>void defaultStandbyTaskAssignment(final ApplicationState applicationState, 
                                                    final Map<ProcessId, KafkaStreamsAssignment> KafkaStreamsAssignments);

    /**
     * Optimize active task assignment for rack awareness. This optimization is            final Map<ProcessID, KafkaStreamsAssignment> KafkaStreamsAssignments);

    /**
     * Optimize active task assignment for rack awareness. This optimization is based based on the 
     * {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_TRAFFIC_COST_CONFIG trafficCost} 
     * and {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_NON_OVERLAP_COST_CONFIG nonOverlapCost}
     * configs which balance cross rack traffic minimization and task movement.
     * Setting {@code trafficCost} to a larger number reduces the overall cross rack traffic of the resulting 
     * assignment, but can increase the number of tasks shuffled around between clients. 
     * Setting {@code nonOverlapCost} to a larger number increases the affinity of tasks to their intended client
     * and reduces the amount by which the rack-aware optimization can shuffle tasks around, at the cost of higher
     * cross-rack traffic.
     * In an extreme case, if we set {@code nonOverlapCost} to 0 and @{code trafficCost} to a positive value,
     * the resulting assignment will have an absolute minimum of cross rack traffic. If we set {@code trafficCost} to 0,
     * and {@code nonOverlapCost} to a positive value, the resulting assignment will be identical to the input assignment.    
     * <p>
       * Note:This this method willoptimizes modifycross-rack thetraffic inputfor {@linkactive KafkaStreamsAssignment}tasks objectsonly. andFor returnstandby the same map.task optimization,
     * Ituse does not make a copy of the map or the KafkaStreamsAssignment objects.      {@link #optimizeRackAwareStandbyTasks}.
     * <p>
     * ThisIt methodis optimizesrecommended cross-rackto trafficrun forthis activeoptimization tasksbefore only.assigning Forany standby task optimizationtasks,
 especially if you have *configured
 use {@link #optimizeRackAwareStandbyTasks}.
  * your KafkaStreams *
clients with assignment tags via * @param applicationState    the rack.aware.assignment.tags config since this method may
    the metadata and other info describing the current application state
     * @param kafkaStreamsAssignments the current assignment of tasks to KafkaStreams clients* shuffle around active tasks without considering the client tags and can result in a violation of the original
     * client tag assignment's constraints.
     *
 @param tasks   * @param kafkaStreamsAssignments the assignment of tasks to KafkaStreams clients to be optimized
     * the set of tasks to reassign if possible. Must already be assigned to a KafkaStreams client
     *@param optimizationParams      optional configuration parameters to apply 
     */
    public static 
void optimizeRackAwareActiveTasks(final Map<ProcessId, KafkaStreamsAssignment> kafkaStreamsAssignments,
 *  @return  a  map  with  the  KafkaStreamsAssignments  updated  to  minimize  cross-rack  traffic  for  active  tasks
      */
        public  static  Map<ProcessID,  KafkaStreamsAssignment>  optimizeRackAwareActiveTasks(final final ApplicationState applicationState, 
  RackAwareOptimizationParams optimizationParams);      

    /**
     * Optimize standby task assignment for rack awareness. This optimization is based on the 
     *      {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_TRAFFIC_COST_CONFIG trafficCost} 
     * and {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_NON_OVERLAP_COST_CONFIG nonOverlapCost}
     * configs which balance cross rack traffic minimization and task movement.
     * Setting {@code trafficCost} to a larger number reduces the overall cross rack traffic of the resulting 
    final Map<ProcessID, KafkaStreamsAssignment> kafkaStreamsAssignments* assignment, 
but can increase the number of tasks shuffled around between clients. 
     * Setting {@code nonOverlapCost} to a larger number increases the affinity of tasks to their intended client
     * and reduces the amount by which the rack-aware optimization can shuffle tasks around, at the cost of higher
     * cross-rack traffic.
     * In an extreme case, if we set {@code nonOverlapCost} to 0 and @{code trafficCost} to a   final SortedSet<TaskId> tasks);      

    /**
     * Optimize standby task assignment for rack awareness. This optimization is based on the 
     * {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_TRAFFIC_COST_CONFIG trafficCost} positive value,
     * the resulting assignment will have an absolute minimum of cross rack traffic. If we set {@code trafficCost} to 0,
     * and {@link StreamsConfig#RACK_AWARE_ASSIGNMENT_NON_OVERLAP_COST_CONFIG@code nonOverlapCost}
 to a positive value, *the configsresulting whichassignment balancewill crossbe rackidentical trafficto minimizationthe andinput task movementassignment.
     * Setting<p>
 {@code trafficCost} to a larger* numberThis reducesmethod the overalloptimizes cross -rack traffic offor thestandby resultingtasks 
only. For active task  * assignment, but can increase the number of tasks shuffled around between clients. optimization,
     * use {@link #optimizeRackAwareActiveTasks}.
     * Setting
 {@code nonOverlapCost} to a larger* number@param increasesKafkaStreamsAssignments the affinitycurrent assignment of tasks to theirKafkaStreams intended clientclients
       * and@param reducesoptimizationParams the amount by which the rack-awareoptional optimizationconfiguration canparameters shuffleto tasksapply around,
 at the cost of higher
   */
    public static void * cross-rack traffic.
     * In an extreme case, if we set {@code nonOverlapCost} to 0 and @{code trafficCost} to a positive value,
     * the resulting assignment will have an absolute minimum of cross rack traffic. If we set {@code trafficCost} to 0,optimizeRackAwareStandbyTasks(final Map<ProcessId, KafkaStreamsAssignment> kafkaStreamsAssignments,
                                                     final RackAwareOptimizationParams optimizationParams);

    /**
     * Return a "no-op" assignment that just copies the previous assignment of tasks to KafkaStreams clients
     *
 and {@code nonOverlapCost} to a* positive@param value,applicationState the resultingmetadata assignmentand willother beinfo identicaldescribing tothe thecurrent inputapplication assignment.state
     * <p>
     * @return *a Thisnew methodmap optimizescontaining cross-rackan trafficassignment forthat standbyreplicates tasksexactly only.the Forprevious activeassignment taskreported optimization,
in the applicationState
     */
 use {@link #optimizeRackAwareActiveTasks}.
 public static Map<ProcessId, KafkaStreamsAssignment> * identityAssignment(final ApplicationState applicationState);

    /**
 *  @param KafkaStreamsAssignments the* currentValidate assignmentthe of tasks to KafkaStreams clients
     * @param applicationState        the metadata and other info describing the current application statepassed-in {@link TaskAssignment} and return an {@link AssignmentError} representing the
     * first error detected in the assignment, or {@link AssignorError.NONE} if the assignment passes the
     * verification check.
     * @return a* new<p>
 map containing the mappings from* KafkaStreamsAssignmentsNote: updatedthis withverification theis defaultperformed rack-awareautomatically assignmentby forthe standyStreamsPartitionAssignor tasks
on the    */assignment
    public static* Map<ProcessID,returned KafkaStreamsAssignment>by optimizeRackAwareStandbyTasks(final ApplicationState applicationState,
           the TaskAssignor, and the error returned to the assignor via the {@link TaskAssignor#onAssignmentComputed}
     * callback. Therefore, it is not required to call this manually from the {@link TaskAssignor#assign} method.
     * However if an invalid assignment is returned it will fail the rebalance and kill the thread, so it may be useful to
     * utilize this method in an assignor to verify the assignment before returning it and fix any errors     it finds.
  final Map<ProcessID, KafkaStreamsAssignment> kafkaStreamsAssignments);

    /**
     * Return@param a "no-op" assignment that just copies the previousapplicationState The application for which this task assignment ofis tasks to KafkaStreams clientsbeing assessed.
     *
 @param taskAssignment   *The @paramtask applicationStateassignment thethat metadatawill andbe othervalidated.
 info describing the current application state*
     *
     * @return a new map containing an assignment that replicates exactly the previous assignment reported in the applicationState
     @return {@code AssignmentError.NONE} if the assignment created for this application is valid,
     *         or another {@code AssignmentError} otherwise.
     */
    public static Map<ProcessID, KafkaStreamsAssignment> identityAssignmentAssignmentError validateTaskAssignment(final ApplicationState applicationState);
 },
                                                         final TaskAssignment taskAssignment) {
  }