/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the "Elastic License
 * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
 * Public License v 1"; you may not use this file except in compliance with, at
 * your election, the "Elastic License 2.0", the "GNU Affero General Public
 * License v3.0 only", or the "Server Side Public License, v 1".
 */

package org.elasticsearch.cluster.metadata;

import org.elasticsearch.common.io.stream.Writeable;
import org.elasticsearch.test.AbstractXContentSerializingTestCase;
import org.elasticsearch.xcontent.XContentParser;

import java.io.IOException;
import java.util.Arrays;
import java.util.stream.IntStream;

public class IndexReshardingMetadataSerializationTests extends AbstractXContentSerializingTestCase<IndexReshardingMetadata> {
    @Override
    protected IndexReshardingMetadata doParseInstance(XContentParser parser) throws IOException {
        return IndexReshardingMetadata.fromXContent(parser);
    }

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

    @Override
    protected IndexReshardingMetadata createTestInstance() {
        if (randomBoolean()) {
            return new IndexReshardingMetadata(createTestSplit());
        } else {
            return new IndexReshardingMetadata(new IndexReshardingState.Noop());
        }
    }

    private IndexReshardingState.Split createTestSplit() {
        final int oldShards = randomIntBetween(1, 100);
        final int newShards = randomIntBetween(2, 5) * oldShards;
        final var sourceShardStates = new IndexReshardingState.Split.SourceShardState[oldShards];
        final var targetShardStates = new IndexReshardingState.Split.TargetShardState[newShards - oldShards];
        // Semantically it is illegal for SourceShardState to be DONE before all corresponding target shards are
        // DONE but these tests are exercising equals/hashcode not semantic integrity. Letting the source shard
        // state vary randomly gives better coverage in fewer instances even though it is wrong semantically.
        for (int i = 0; i < oldShards; i++) {
            sourceShardStates[i] = randomFrom(IndexReshardingState.Split.SourceShardState.values());
        }
        // All sources done is an invalid state, will fail assert in Split constructor
        if (Arrays.stream(sourceShardStates).allMatch(state -> state == IndexReshardingState.Split.SourceShardState.DONE)) {
            sourceShardStates[0] = IndexReshardingState.Split.SourceShardState.SOURCE;
        }
        for (int i = 0; i < targetShardStates.length; i++) {
            targetShardStates[i] = randomFrom(IndexReshardingState.Split.TargetShardState.values());
        }

        return new IndexReshardingState.Split(sourceShardStates, targetShardStates);
    }

    @Override
    protected IndexReshardingMetadata mutateInstance(IndexReshardingMetadata instance) throws IOException {
        var state = switch (instance.getState()) {
            case IndexReshardingState.Noop ignored -> createTestSplit();
            case IndexReshardingState.Split split -> mutateSplit(split);
        };
        return new IndexReshardingMetadata(state);
    }

    // To exercise equals() we want to mutate exactly one thing randomly so we know that each component
    // is contributing to equality testing. Some of these mutations are semantically illegal but we ignore
    // that here.
    private IndexReshardingState.Split mutateSplit(IndexReshardingState.Split split) {
        enum Mutation {
            SOURCE_SHARD_STATES,
            TARGET_SHARD_STATES
        }

        var sourceShardStates = split.sourceShards().clone();
        var targetShardStates = split.targetShards().clone();

        var is = randomInt(sourceShardStates.length - 1);
        boolean allOtherSourcesDone = IntStream.range(0, sourceShardStates.length)
            .filter(i -> i != is)
            .allMatch(i -> sourceShardStates[i] == IndexReshardingState.Split.SourceShardState.DONE);
        // All sources done is an invalid state, will fail assert in Split constructor
        if (allOtherSourcesDone || randomFrom(Mutation.values()) == Mutation.TARGET_SHARD_STATES) {
            var it = randomInt(targetShardStates.length - 1);
            targetShardStates[it] = IndexReshardingState.Split.TargetShardState.values()[(targetShardStates[it].ordinal() + 1)
                % IndexReshardingState.Split.TargetShardState.values().length];
        } else {
            sourceShardStates[is] = IndexReshardingState.Split.SourceShardState.values()[(sourceShardStates[is].ordinal() + 1)
                % IndexReshardingState.Split.SourceShardState.values().length];
        }

        return new IndexReshardingState.Split(sourceShardStates, targetShardStates);
    }
}