package org.apache.kafka.connect.rest.extension;
public interface ConnectRestExtension extends Configurable, Versionable, Closeable {
    /**
     * ConnectRestExtension implementations register custom JAX-RS resources via the {@link
     * #register(ConnectRestExtensionContext)} method. Framework will invoke this method after
     * registering the default Connect resources. If the implementations attempt to re-register any
     * of the Connect Resources, it will be be ignored and will be logged.
     *
     * @param restPluginContext The context provides access to JAX-RS {@link javax.ws.rs.core.Configurable}
     *                          and {@link ConnectClusterState}.The custom JAX-RS resources can be
     *                          registered via the {@link ConnectRestExtensionContext#configurable()}
     */
    void register(ConnectRestExtensionContext restPluginContext);
}

package org.apache.kafka.connect.components;
public interface Versionable {
    /**
     * Get the version of this component.
     *
     * @return the version, formatted as a String
     */
    String version();
}

package org.apache.kafka.connect.rest.extension;
interface ConnectRestExtensionContext{
    /**
     *
     * @return return a  implementation of {@link javax.ws.rs.core.Configurable} that be used ot
     * register JAX-RS resources
     */
    Configurable<? extends Configurable> configurable();
    /**
     * Provides meta data about connector's and its health
     * @return instance of {@link ConnectClusterState}
     */
    ConnectClusterState clusterState();
}

package org.apache.kafka.connect.rest.extension;
interface ConnectClusterState{
    /**
     * Get a list of connectors currently running in this cluster. This is a full list of connectors in the cluster gathered
     * from the current configuration.
     */
    Collection<String> connectors();
 
    /**
     * Lookup the current status of a connector.
     * @param connName name of the connector
     */
    ConnectorHealth connectorHealth(String connName);
 
}
 
package org.apache.kafka.connect.rest.extension.entities;
public class ConnectorHealth {

    private final String name;
    private final ConnectorState connector;
    private final Map<Integer, TaskState> tasks;
    private final ConnectorType type;


    public ConnectorHealth(String name,
                           ConnectorState connector,
                           Map<Integer, TaskState> tasks,
                           ConnectorType type) {
        this.name = name;
        this.connector = connector;
        this.tasks = tasks;
        this.type = type;
    }


    public String name() {
        return name;
    }


    public ConnectorState connectorState() {
        return connector;
    }


    public Map<Integer, TaskState> tasksState() {
        return tasks;
    }


    public ConnectorType type() {
        return type;
    }

    public abstract static class AbstractState {

        private final String state;
        private final String trace;
        private final String workerId;

        public AbstractState(String state, String workerId, String trace) {
            this.state = state;
            this.workerId = workerId;
            this.trace = trace;
        }

        public String state() {
            return state;
        }


        public String workerId() {
            return workerId;
        }

        public String trace() {
            return trace;
        }
    }

    public static class ConnectorState extends AbstractState {

        public ConnectorState(String state, String worker, String msg) {
            super(state, worker, msg);
        }
    }

    public static class TaskState extends AbstractState implements Comparable<TaskState> {

        private final int id;

        public TaskState(int id, String state, String worker, String msg) {
            super(state, worker, msg);
            this.id = id;
        }

        public int id() {
            return id;
        }

        @Override
        public int compareTo(TaskState that) {
            return Integer.compare(this.id, that.id);
        }

        @Override
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }
            if (!(o instanceof TaskState)) {
                return false;
            }
            TaskState other = (TaskState) o;
            return compareTo(other) == 0;
        }

        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }

}