// Copyright (C) MongoDB, Inc. 2019-present.
//
// Licensed 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

package operation

import (
	"context"
	"errors"
	"fmt"
	"time"

	"go.mongodb.org/mongo-driver/v2/event"
	"go.mongodb.org/mongo-driver/v2/internal/driverutil"
	"go.mongodb.org/mongo-driver/v2/mongo/writeconcern"
	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
	"go.mongodb.org/mongo-driver/v2/x/mongo/driver"
	"go.mongodb.org/mongo-driver/v2/x/mongo/driver/description"
	"go.mongodb.org/mongo-driver/v2/x/mongo/driver/session"
)

// DropIndexes performs an dropIndexes operation.
type DropIndexes struct {
	authenticator             driver.Authenticator
	index                     any
	session                   *session.Client
	clock                     *session.ClusterClock
	collection                string
	monitor                   *event.CommandMonitor
	maxAdaptiveRetries        uint
	enableOverloadRetargeting bool
	crypt                     driver.Crypt
	database                  string
	deployment                driver.Deployment
	selector                  description.ServerSelector
	writeConcern              *writeconcern.WriteConcern
	result                    DropIndexesResult
	serverAPI                 *driver.ServerAPIOptions
	timeout                   *time.Duration
	rawData                   *bool
}

// DropIndexesResult represents a dropIndexes result returned by the server.
type DropIndexesResult struct {
	// Number of indexes that existed before the drop was executed.
	NIndexesWas int32
}

func buildDropIndexesResult(response bsoncore.Document) (DropIndexesResult, error) {
	elements, err := response.Elements()
	if err != nil {
		return DropIndexesResult{}, err
	}
	dir := DropIndexesResult{}
	for _, element := range elements {
		if element.Key() == "nIndexesWas" {
			var ok bool
			dir.NIndexesWas, ok = element.Value().AsInt32OK()
			if !ok {
				return dir, fmt.Errorf("response field 'nIndexesWas' is type int32, but received BSON type %s", element.Value().Type)
			}
		}
	}
	return dir, nil
}

// NewDropIndexes constructs and returns a new DropIndexes.
func NewDropIndexes(index any) *DropIndexes {
	return &DropIndexes{
		index: index,
	}
}

// Result returns the result of executing this operation.
func (di *DropIndexes) Result() DropIndexesResult { return di.result }

func (di *DropIndexes) processResponse(_ context.Context, resp bsoncore.Document, _ driver.ResponseInfo) error {
	var err error
	di.result, err = buildDropIndexesResult(resp)
	return err
}

// Execute runs this operations and returns an error if the operation did not execute successfully.
func (di *DropIndexes) Execute(ctx context.Context) error {
	if di.deployment == nil {
		return errors.New("the DropIndexes operation must have a Deployment set before Execute can be called")
	}

	return driver.Operation{
		CommandFn:                 di.command,
		ProcessResponseFn:         di.processResponse,
		Client:                    di.session,
		Clock:                     di.clock,
		CommandMonitor:            di.monitor,
		MaxAdaptiveRetries:        di.maxAdaptiveRetries,
		EnableOverloadRetargeting: di.enableOverloadRetargeting,
		Crypt:                     di.crypt,
		Database:                  di.database,
		Deployment:                di.deployment,
		Selector:                  di.selector,
		WriteConcern:              di.writeConcern,
		ServerAPI:                 di.serverAPI,
		Timeout:                   di.timeout,
		Name:                      driverutil.DropIndexesOp,
		Authenticator:             di.authenticator,
		SendAfterClusterTime:      true,
	}.Execute(ctx)
}

func (di *DropIndexes) command(dst []byte, desc description.SelectedServer) ([]byte, error) {
	dst = bsoncore.AppendStringElement(dst, "dropIndexes", di.collection)

	switch t := di.index.(type) {
	case string:
		dst = bsoncore.AppendStringElement(dst, "index", t)
	case bsoncore.Document:
		if di.index != nil {
			dst = bsoncore.AppendDocumentElement(dst, "index", t)
		}
	}
	// Set rawData for 8.2+ servers.
	if di.rawData != nil && desc.WireVersion != nil && driverutil.VersionRangeIncludes(*desc.WireVersion, 27) {
		dst = bsoncore.AppendBooleanElement(dst, "rawData", *di.rawData)
	}

	return dst, nil
}

// Index specifies the name of the index to drop. If '*' is specified, all indexes will be dropped.
func (di *DropIndexes) Index(index any) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.index = index
	return di
}

// Session sets the session for this operation.
func (di *DropIndexes) Session(session *session.Client) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.session = session
	return di
}

// ClusterClock sets the cluster clock for this operation.
func (di *DropIndexes) ClusterClock(clock *session.ClusterClock) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.clock = clock
	return di
}

// Collection sets the collection that this command will run against.
func (di *DropIndexes) Collection(collection string) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.collection = collection
	return di
}

// CommandMonitor sets the monitor to use for APM events.
func (di *DropIndexes) CommandMonitor(monitor *event.CommandMonitor) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.monitor = monitor
	return di
}

// MaxAdaptiveRetries specifies the maximum number of times the driver should retry operations
// that fail with a server side overload error.
func (di *DropIndexes) MaxAdaptiveRetries(maxAdaptiveRetries uint) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.maxAdaptiveRetries = maxAdaptiveRetries
	return di
}

// EnableOverloadRetargeting specifies whether the driver adds the previously failed server's address
// to the list of deprioritized server addresses
func (di *DropIndexes) EnableOverloadRetargeting(enabled bool) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.enableOverloadRetargeting = enabled
	return di
}

// Crypt sets the Crypt object to use for automatic encryption and decryption.
func (di *DropIndexes) Crypt(crypt driver.Crypt) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.crypt = crypt
	return di
}

// Database sets the database to run this operation against.
func (di *DropIndexes) Database(database string) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.database = database
	return di
}

// Deployment sets the deployment to use for this operation.
func (di *DropIndexes) Deployment(deployment driver.Deployment) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.deployment = deployment
	return di
}

// ServerSelector sets the selector used to retrieve a server.
func (di *DropIndexes) ServerSelector(selector description.ServerSelector) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.selector = selector
	return di
}

// WriteConcern sets the write concern for this operation.
func (di *DropIndexes) WriteConcern(writeConcern *writeconcern.WriteConcern) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.writeConcern = writeConcern
	return di
}

// ServerAPI sets the server API version for this operation.
func (di *DropIndexes) ServerAPI(serverAPI *driver.ServerAPIOptions) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.serverAPI = serverAPI
	return di
}

// Timeout sets the timeout for this operation.
func (di *DropIndexes) Timeout(timeout *time.Duration) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.timeout = timeout
	return di
}

// Authenticator sets the authenticator to use for this operation.
func (di *DropIndexes) Authenticator(authenticator driver.Authenticator) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.authenticator = authenticator
	return di
}

// RawData sets the rawData to access timeseries data in the compressed format.
func (di *DropIndexes) RawData(rawData bool) *DropIndexes {
	if di == nil {
		di = new(DropIndexes)
	}

	di.rawData = &rawData
	return di
}
