package event

import (
	"fmt"
	"net/http"
	"strings"
	"sync"
)

// Target - lambda target interface
type Target interface {
	ID() TargetID
	IsActive() (bool, error)
	Send(Event) (*http.Response, error)
	Stat() TargetStat
	Close() error
}

// TargetStats is a collection of stats for multiple targets.
type TargetStats struct {
	TargetStats map[string]TargetStat
}

}

// Record - is a type containing columns and their values.
type Record interface {
	Get(name string) (*Value, error)

	// Set a value.
	// Can return a different record type.
	Set(name string, value *Value) (Record, error)
	WriteCSV(writer io.Writer, opts WriteCSVOpts) error
	WriteJSON(writer io.Writer) error

	// Clone the record and if possible use the destination provided.
	Clone(dst Record) Record
	Reset()

	}
	// Avoid bugs in long file names
	// https://github.com/golang/tools/commit/5f9a5413737ba4b4f692214aebee582b47c8be74
	nameLen := bytes.IndexByte(nameBuf[:limit], 0)
	if nameLen < 0 {
		return 0, fmt.Errorf("failed to find terminating 0 byte in dirent")
	}
	return uint64(nameLen), nil

	zDump := c.ztunnelDump
	policies := slices.Filter(zDump.Policies, filter.Verify)
	slices.SortFunc(policies, func(a, b *ZtunnelPolicy) int {
		if r := cmp.Compare(a.Namespace, b.Namespace); r != 0 {
			return r
		}
		return cmp.Compare(a.Name, b.Name)
	})
	out, err := json.MarshalIndent(policies, "", "    ")
	if err != nil {
		return fmt.Errorf("failed to marshal policies: %v", err)
	}

			t.Fatalf("MinIO %s: Failed parsing response body: <ERROR> %v", instanceType, err)
		}

		actualError := &APIErrorResponse{}
		if err = xml.Unmarshal(actualContent, actualError); err != nil {
			t.Errorf("MinIO %s: error response failed to parse error XML", instanceType)
		}

		if actualError.BucketName != bucketName {
			t.Errorf("MinIO %s: error response bucket name differs from expected value", instanceType)

	failAfter int
}

func newMockReader(failAfter int, data byte) *mockReader {
	return &mockReader{0, data, failAfter}
}

func (r *mockReader) Read(p []byte) (n int, err error) {
	if r.pos >= r.failAfter {
		return 0, fmt.Errorf("intentionally unexpected reader error")
	}
	r.pos++
	p[0] = r.mockData
	return 1, nil
}

func TestScannerFailure(t *testing.T) {
	var (
		i         int
		failAfter = 900

}

// TransferError will catch network errors during transfer.
// When TransferError() is called Close() will also
// be called, so we do not need to Wait() here.
func (w *writerAt) TransferError(err error) {
	_ = w.w.CloseWithError(err)
	_ = w.r.CloseWithError(err)
	w.err = err
}

func (w *writerAt) Close() (err error) {
	switch {
	case len(w.buffer) > 0:

	info.Ffree = uint64(lpNumberOfFreeClusters)

	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

	207, 151, 211, 146, // message crc.
}

// newErrorMessage - creates new Request Level Error Message. S3 sends this message if the request failed for any reason.
// It contains the error code and error message for the failure. If S3 sends a RequestLevelError message,
// it doesn't send an End message.
//
// Header specification:
// Request-level error messages contain three headers, as follows:

	default:
		return nil, errInvalidCompressionFormat(fmt.Errorf("unknown compression type '%v'", compType))
	}
	pr.processedReader = newCountUpReader(r)

	return &pr, nil
}

type nopReadCloser struct {
	fn func()
}

func (n2 *nopReadCloser) Read(p []byte) (n int, err error) {
	panic("should not be called")
}

func (n2 *nopReadCloser) Close() error {
	if n2.fn != nil {
		n2.fn()
	}