// Code generated by smithy-go-codegen DO NOT EDIT.

package kinesis

import (
	"context"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Splits a shard into two new shards in the Kinesis data stream, to increase the
// stream's capacity to ingest and transport data. SplitShard is called when there
// is a need to increase the overall capacity of a stream because of an expected
// increase in the volume of data records being ingested. This API is only
// supported for the data streams with the provisioned capacity mode. When invoking
// this API, it is recommended you use the StreamARN input parameter rather than
// the StreamName input parameter. You can also use SplitShard when a shard
// appears to be approaching its maximum utilization; for example, the producers
// sending data into the specific shard are suddenly sending more than previously
// anticipated. You can also call SplitShard to increase stream capacity, so that
// more Kinesis Data Streams applications can simultaneously read data from the
// stream for real-time processing. You must specify the shard to be split and the
// new hash key, which is the position in the shard where the shard gets split in
// two. In many cases, the new hash key might be the average of the beginning and
// ending hash key, but it can be any hash key value in the range being mapped into
// the shard. For more information, see Split a Shard (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html)
// in the Amazon Kinesis Data Streams Developer Guide. You can use
// DescribeStreamSummary and the ListShards APIs to determine the shard ID and
// hash key values for the ShardToSplit and NewStartingHashKey parameters that are
// specified in the SplitShard request. SplitShard is an asynchronous operation.
// Upon receiving a SplitShard request, Kinesis Data Streams immediately returns a
// response and sets the stream status to UPDATING . After the operation is
// completed, Kinesis Data Streams sets the stream status to ACTIVE . Read and
// write operations continue to work while the stream is in the UPDATING state.
// You can use DescribeStreamSummary to check the status of the stream, which is
// returned in StreamStatus . If the stream is in the ACTIVE state, you can call
// SplitShard . If the specified stream does not exist, DescribeStreamSummary
// returns a ResourceNotFoundException . If you try to create more shards than are
// authorized for your account, you receive a LimitExceededException . For the
// default shard limit for an Amazon Web Services account, see Kinesis Data
// Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
// in the Amazon Kinesis Data Streams Developer Guide. To increase this limit,
// contact Amazon Web Services Support (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html)
// . If you try to operate on too many streams simultaneously using CreateStream ,
// DeleteStream , MergeShards , and/or SplitShard , you receive a
// LimitExceededException . SplitShard has a limit of five transactions per second
// per account.
func (c *Client) SplitShard(ctx context.Context, params *SplitShardInput, optFns ...func(*Options)) (*SplitShardOutput, error) {
	if params == nil {
		params = &SplitShardInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "SplitShard", params, optFns, c.addOperationSplitShardMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*SplitShardOutput)
	out.ResultMetadata = metadata
	return out, nil
}

// Represents the input for SplitShard .
type SplitShardInput struct {

	// A hash key value for the starting hash key of one of the child shards created
	// by the split. The hash key range for a given shard constitutes a set of ordered
	// contiguous positive integers. The value for NewStartingHashKey must be in the
	// range of hash keys being mapped into the shard. The NewStartingHashKey hash key
	// value and all higher hash key values in hash key range are distributed to one of
	// the child shards. All the lower hash key values in the range are distributed to
	// the other child shard.
	//
	// This member is required.
	NewStartingHashKey *string

	// The shard ID of the shard to split.
	//
	// This member is required.
	ShardToSplit *string

	// The ARN of the stream.
	StreamARN *string

	// The name of the stream for the shard split.
	StreamName *string

	noSmithyDocumentSerde
}

type SplitShardOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata

	noSmithyDocumentSerde
}

func (c *Client) addOperationSplitShardMiddlewares(stack *middleware.Stack, options Options) (err error) {
	err = stack.Serialize.Add(&awsAwsjson11_serializeOpSplitShard{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSplitShard{}, middleware.After)
	if err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack, options); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addOpSplitShardValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSplitShard(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opSplitShard(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		SigningName:   "kinesis",
		OperationName: "SplitShard",
	}
}