sync

type BuggifyChecker interface {
	Check(site string, probability float64) bool
}

type CkinLockFail struct {
	HeldBy string
	Since  time.Time
}

type CkinLockReq struct {
	ParentUUID string
	ClientID   string
}

type CloneOpts struct {
	User     string // Credentials for clone auth (also default admin user)
	Password string
	Version  int            // Protocol version (default 3)
	Env      *simio.Env     // nil defaults to RealEnv
	Observer Observer       // nil defaults to no-op
	Buggify  BuggifyChecker // fault injection for DST (nil = no faults)
}

type CloneResult struct {
	Rounds          int
	BlobsRecvd      int
	ArtifactsLinked int // Manifests crosslinked into event table
	ProjectCode     string
	ServerCode      string
	Messages        []string // Informational messages from server
}

type HTTPTransport struct {
	URL string // repo root, e.g. "http://localhost:8080"
}

type HandleEnd struct {
	CardsProcessed int
	FilesSent      int
	FilesReceived  int
	Err            error
}

type HandleFunc func(ctx context.Context, r *repo.Repo, req *xfer.Message) (*xfer.Message, error)

type HandleOpts struct {
	Buggify      BuggifyChecker // nil in production.
	Observer     Observer       // nil defaults to no-op.
	ContentCache *content.Cache // nil = no caching.
}

type HandleStart struct {
	Operation   string // "sync" or "clone"
	ProjectCode string
	RemoteAddr  string
}

type MockTransport struct {
	Handler func(req *xfer.Message) *xfer.Message
}

type Observer interface {
	// Client-side session lifecycle.
	Started(ctx context.Context, info SessionStart) context.Context
	RoundStarted(ctx context.Context, round int) context.Context
	RoundCompleted(ctx context.Context, round int, stats RoundStats)
	Completed(ctx context.Context, info SessionEnd, err error)

	// Per-error recording — called on individual protocol errors.
	Error(ctx context.Context, err error)

	// Server-side request lifecycle.
	HandleStarted(ctx context.Context, info HandleStart) context.Context
	HandleCompleted(ctx context.Context, info HandleEnd)

	// Table sync lifecycle.
	TableSyncStarted(ctx context.Context, info TableSyncStart)
	TableSyncCompleted(ctx context.Context, info TableSyncEnd)
}

type PhantomStallError struct {
	Count  int      // phantom UUIDs still outstanding when the clone stopped
	Sample []string // up to phantomStallSampleSize lexicographically-smallest of those UUIDs, for diagnosis
}

type RoundStats struct {
	FilesSent     int
	FilesReceived int
	GimmesSent    int
	IgotsSent     int
	BytesSent     int64
	BytesReceived int64
}

type SessionEnd struct {
	Operation                 string
	Rounds                    int
	FilesSent, FilesRecvd     int
	UVFilesSent, UVFilesRecvd int
	UVGimmesSent              int
	BytesSent, BytesRecvd     int64
	ProjectCode               string
	Errors                    []string
}

type SessionStart struct {
	Operation   string // "sync" or "clone"
	Push, Pull  bool
	UV          bool
	ProjectCode string
	PeerID      string // identifies the leaf agent instance
}

type StatusError struct {
	Code   int    // HTTP status code
	Status string // HTTP status line, e.g. "503 Service Unavailable"
}

type SyncOpts struct {
	Push, Pull   bool           // enable push/pull directions (at least one must be true)
	ProjectCode  string         // repo's project-code — sent to identify the repository
	ServerCode   string         // server-code from a previous session (cookie-like, speeds up sync)
	User         string         // login user — empty means unauthenticated "nobody" sync
	Password     string         // login password
	PeerID       string         // identifies this leaf agent instance (for observability)
	MaxSend      int            // byte budget per round for file payloads (0 defaults to DefaultMaxSend)
	UV           bool           // enable unversioned file sync (wiki, forum, attachments)
	XTableSync   bool           // enable extension table sync (peer_registry, etc.) — only between EdgeSync peers
	Private      bool           // enable private artifact sync
	Env          *simio.Env     // nil defaults to RealEnv
	Buggify      BuggifyChecker // nil in production — used by DST for fault injection
	Observer     Observer       // nil defaults to no-op
	CkinLock     *CkinLockReq   // nil = no lock requested
	ContentCache *content.Cache // nil = no caching (every Expand walks the full delta chain)
}

type SyncResult struct {
	Rounds, FilesSent, FilesRecvd int
	UVFilesSent, UVFilesRecvd     int
	UVGimmesSent                  int
	BytesSent, BytesRecvd         int64
	ArtifactsLinked               int
	Errors                        []string
	CkinLockFail                  *CkinLockFail // nil = no conflict
}

type SyncedTable struct {
	Info repo.TableInfo
	Def  repo.TableDef
}

type TableSyncEnd struct {
	Table    string
	Sent     int
	Received int
}

type TableSyncStart struct {
	Table     string
	LocalRows int
}

type Transport interface {
	Exchange(ctx context.Context, request *xfer.Message) (*xfer.Message, error)
}

type TransportFault interface {
	error
	// RetryableTransportFault reports whether sending the same request
	// again may succeed. It is true only when no reply was interpreted, so
	// a resend cannot mask a defect in one that was.
	RetryableTransportFault() bool
}