/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 */

/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch licenses this file to you 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.
 */

/*
 * Modifications Copyright OpenSearch Contributors. See
 * GitHub history for details.
 */

package org.opensearch.tasks;

import org.opensearch.client.Requests;
import org.opensearch.common.bytes.BytesReference;
import org.opensearch.common.io.stream.NamedWriteableRegistry;
import org.opensearch.common.io.stream.Writeable;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.test.AbstractSerializingTestCase;

import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Predicate;

public class TaskInfoTests extends AbstractSerializingTestCase<TaskInfo> {

    @Override
    protected TaskInfo doParseInstance(XContentParser parser) {
        return TaskInfo.fromXContent(parser);
    }

    @Override
    protected TaskInfo createTestInstance() {
        return randomTaskInfo();
    }

    @Override
    protected Writeable.Reader<TaskInfo> instanceReader() {
        return TaskInfo::new;
    }

    @Override
    protected NamedWriteableRegistry getNamedWriteableRegistry() {
        return new NamedWriteableRegistry(
            Collections.singletonList(new NamedWriteableRegistry.Entry(Task.Status.class, RawTaskStatus.NAME, RawTaskStatus::new))
        );
    }

    @Override
    protected boolean supportsUnknownFields() {
        return true;
    }

    @Override
    protected Predicate<String> getRandomFieldsExcludeFilter() {
        // status, headers and resource_stats hold arbitrary content, we can't inject random fields in them
        return field -> "status".equals(field) || "headers".equals(field) || field.contains("resource_stats");
    }

    @Override
    protected TaskInfo mutateInstance(TaskInfo info) {
        switch (between(0, 10)) {
            case 0:
                TaskId taskId = new TaskId(info.getTaskId().getNodeId() + randomAlphaOfLength(5), info.getTaskId().getId());
                return new TaskInfo(
                    taskId,
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 1:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType() + randomAlphaOfLength(5),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 2:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction() + randomAlphaOfLength(5),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 3:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription() + randomAlphaOfLength(5),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 4:
                Task.Status newStatus = randomValueOtherThan(info.getStatus(), TaskInfoTests::randomRawTaskStatus);
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    newStatus,
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 5:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime() + between(1, 100),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 6:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos() + between(1, 100),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 7:
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable() == false,
                    false,
                    info.getParentTaskId(),
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 8:
                TaskId parentId = new TaskId(info.getParentTaskId().getNodeId() + randomAlphaOfLength(5), info.getParentTaskId().getId());
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    parentId,
                    info.getHeaders(),
                    info.getResourceStats()
                );
            case 9:
                Map<String, String> headers = info.getHeaders();
                if (headers == null) {
                    headers = new HashMap<>(1);
                } else {
                    headers = new HashMap<>(info.getHeaders());
                }
                headers.put(randomAlphaOfLength(15), randomAlphaOfLength(15));
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    headers,
                    info.getResourceStats()
                );
            case 10:
                Map<String, TaskResourceUsage> resourceUsageMap;
                if (info.getResourceStats() == null) {
                    resourceUsageMap = new HashMap<>(1);
                } else {
                    resourceUsageMap = new HashMap<>(info.getResourceStats().getResourceUsageInfo());
                }
                resourceUsageMap.put(randomAlphaOfLength(5), new TaskResourceUsage(randomNonNegativeLong(), randomNonNegativeLong()));
                return new TaskInfo(
                    info.getTaskId(),
                    info.getType(),
                    info.getAction(),
                    info.getDescription(),
                    info.getStatus(),
                    info.getStartTime(),
                    info.getRunningTimeNanos(),
                    info.isCancellable(),
                    info.isCancelled(),
                    info.getParentTaskId(),
                    info.getHeaders(),
                    new TaskResourceStats(resourceUsageMap)
                );
            default:
                throw new IllegalStateException();
        }
    }

    static TaskInfo randomTaskInfo() {
        return randomTaskInfo(randomBoolean());
    }

    static TaskInfo randomTaskInfo(boolean detailed) {
        TaskId taskId = randomTaskId();
        String type = randomAlphaOfLength(5);
        String action = randomAlphaOfLength(5);
        Task.Status status = detailed ? randomRawTaskStatus() : null;
        String description = detailed ? randomAlphaOfLength(5) : null;
        long startTime = randomLong();
        long runningTimeNanos = randomLong();
        boolean cancellable = randomBoolean();
        boolean cancelled = cancellable == true ? randomBoolean() : false;
        TaskId parentTaskId = randomBoolean() ? TaskId.EMPTY_TASK_ID : randomTaskId();
        Map<String, String> headers = randomBoolean()
            ? Collections.emptyMap()
            : Collections.singletonMap(randomAlphaOfLength(5), randomAlphaOfLength(5));
        return new TaskInfo(
            taskId,
            type,
            action,
            description,
            status,
            startTime,
            runningTimeNanos,
            cancellable,
            cancelled,
            parentTaskId,
            headers,
            randomResourceStats(detailed)
        );
    }

    private static TaskId randomTaskId() {
        return new TaskId(randomAlphaOfLength(5), randomLong());
    }

    private static RawTaskStatus randomRawTaskStatus() {
        try (XContentBuilder builder = XContentBuilder.builder(Requests.INDEX_CONTENT_TYPE.xContent())) {
            builder.startObject();
            int fields = between(0, 10);
            for (int f = 0; f < fields; f++) {
                builder.field(randomAlphaOfLength(5), randomAlphaOfLength(5));
            }
            builder.endObject();
            return new RawTaskStatus(BytesReference.bytes(builder));
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public static TaskResourceStats randomResourceStats(boolean detailed) {
        return detailed ? new TaskResourceStats(new HashMap<String, TaskResourceUsage>() {
            {
                for (int i = 0; i < randomInt(5); i++) {
                    put(randomAlphaOfLength(5), new TaskResourceUsage(randomNonNegativeLong(), randomNonNegativeLong()));
                }
            }
        }) : null;
    }
}
