// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"bytes"
	"context"
	"testing"
)

// Wrapper for calling GetObjectInfo tests for both Erasure multiple disks and single node setup.
func TestGetObjectInfo(t *testing.T) {
	ExecObjectLayerTest(t, testGetObjectInfo)
}

// Testing GetObjectInfo().
func testGetObjectInfo(obj ObjectLayer, instanceType string, t TestErrHandler) {

	driveMetrics, err := c.driveMetrics.Get()
	if err != nil {
		metricsLogIf(ctx, err)
		return nil
	}

	for _, disk := range driveMetrics.storageInfo.Disks {
		labels := []string{
			driveL, disk.DrivePath,
			poolIndexL, strconv.Itoa(disk.PoolIndex),
			setIndexL, strconv.Itoa(disk.SetIndex),
			driveIndexL, strconv.Itoa(disk.DiskIndex),
		}

	flag.Parse()

	localDisks, err := filterLocalDisks(node, args)
	if err != nil {
		log.Fatal(err)
	}

	if len(localDisks) == 0 {
		log.Fatal("Fix --local-node-name or/and --args to select local disks.")
	}

	format, err := getFormatJSON(localDisks[0].path)
	if err != nil {
		log.Fatal(err)
	}

	setSize := len(format.XL.Sets[0])

	expectedDisksName := make(map[string]string)

}

// Get formatted disk/storage info message.
func getStorageInfoMsg(storageInfo StorageInfo) string {
	var msg string
	var mcMessage string
	onlineDisks, offlineDisks := getOnlineOfflineDisksStats(storageInfo.Disks)
	if storageInfo.Backend.Type == madmin.Erasure {
		if offlineDisks.Sum() > 0 {
			mcMessage = "Use `mc admin info` to look for latest server/drive info\n"
		}

// errInvalidRangeSource - returned when given range value exceeds
// the source object size.
var errInvalidRangeSource = errors.New("Range specified exceeds source object size")

// error returned by disks which are to be initialized are waiting for the
// first server to initialize them in distributed set to initialize them.
var errNotFirstDisk = errors.New("Not first drive")

				quotaSize = int64(q.Quota)
			}
		}

		if quotaSize == 0 {
			info := objAPI.StorageInfo(ctx, true)
			info.Backend = objAPI.BackendInfo()

			ci.Capacity = int64(GetTotalUsableCapacity(info.Disks, info))
		} else {
			ci.Capacity = quotaSize
		}
		ci.Available = ci.Capacity - ci.Used

		buf = encodeResponse(&ci)
	default:
		return nil, errFileNotFound
	}

	etag := getMD5Hash(buf)

		if strptr != nil {
			res = append(res, pathJoin(prefix, name, *strptr))
		}
		return true
	})
	return res
}

// activeDrives returns the number of currently active disks.
// (since this is concurrent it may not be 100% reliable)
func (p *scannerMetrics) activeDrives() int {
	var i int
	p.currentPaths.Range(func(k, v interface{}) bool {
		i++
		return true
	})
	return i

		VersionID:   m.VersionID,
		DataDir:     m.DataDir,
		XLV1:        true,
		NumVersions: 1,
	}

	return fi, nil
}

// Signature will return a signature that is expected to be the same across all disks.
func (m *xlMetaV1Object) Signature() [4]byte {
	// Shallow copy
	c := *m
	// Zero unimportant fields
	c.Erasure.Index = 0
	c.Minio.Release = ""
	crc := hashDeterministicString(c.Meta)
	c.Meta = nil

		} else if bitrotHeal == 1 {
			return newBuf, errFileCorrupt
		}
		return newBuf, nil
	}

	// If we cannot decode, just return read quorum error.
	return nil, fmt.Errorf("%w (offline-disks=%d/%d)", errErasureReadQuorum, disksNotFound, len(p.readers))
}

// Decode reads from readers, reconstructs data if needed and writes the data to the writer.