transport

type AckData struct {
	SessionID string `json:"session_id"` // Edit session UUID
	Revision  int64  `json:"revision"`   // Acknowledged revision
	Timestamp int64  `json:"timestamp"`
}

type ApplyPatchResult struct {
	Content        string // Reconstructed content
	Success        bool   // Whether patch application succeeded
	PatchesApplied int    // Number of patches applied
}

type BaseTransport struct {
	// contains filtered or unexported fields
}

type ClientInfo struct {
	ClientID  string      `json:"client_id"`
	Name      string      `json:"name,omitempty"`
	Color     string      `json:"color,omitempty"`
	IsEditing bool        `json:"is_editing"` // Whether this client is editing (vs just viewing)
	Selection *CursorData `json:"selection,omitempty"`
	UpdatedAt int64       `json:"updated_at"`
}

type ContentStorage interface {
	Get(ctx context.Context, contentPath string, options *session.GetOptions) (*session.ContentModel, error)
}

type CursorData struct {
	Position     int `json:"position"`
	SelectionEnd int `json:"selection_end"`
}

type DocumentSubscription struct {
	DocPath   string
	SessionID string
	ReadOnly  bool
	// contains filtered or unexported fields
}

type EditSession struct {
	SessionID string                    // UUID
	FilePath  string                    // File path
	RefCount  *SessionRefCount          // Reader/Writer counts
	CreatedAt int64                     // Session creation time
	UpdatedAt int64                     // Last update time
	Clients   map[string]*SessionClient // Connected clients (clientID -> client)
	// contains filtered or unexported fields
}

type ErrorData struct {
	SessionID string                 `json:"session_id,omitempty"`
	Code      string                 `json:"code"`    // Error code
	Message   string                 `json:"message"` // Human-readable message
	Details   map[string]interface{} `json:"details,omitempty"`
}

type HeartbeatData struct {
	SessionIDs []string `json:"session_ids"` // All sessions client is subscribed to
}

type HistoryEvent struct {
	SessionID  string                 `json:"session_id"`
	FilePath   string                 `json:"file_path"`
	EventType  string                 `json:"event_type"` // "snapshot" or "operation"
	VersionID  int64                  `json:"version_id"`
	Content    string                 `json:"content,omitempty"`    // Full content for snapshot
	Operations []interface{}          `json:"operations,omitempty"` // OT operations
	CreatedAt  int64                  `json:"created_at"`
	CreatedBy  string                 `json:"created_by"`
	Metadata   map[string]interface{} `json:"metadata,omitempty"` // Additional metadata (patches, etc.)
}

type HistoryListener interface {
	// OnSnapshot is called when a new snapshot is created.
	OnSnapshot(event *HistoryEvent) error

	// OnOperation is called when a new operation is applied.
	OnOperation(event *HistoryEvent) error

	// Close closes the history listener.
	Close() error
}

type HistoryOptions struct {
	// UsePatchMode enables diff-match-patch for efficient storage.
	// When true, stores only patches between versions (like HedgeDoc).
	// When false, stores full content for each version (simpler, more storage).
	UsePatchMode bool

	// MaxChangesBeforeSnapshot triggers snapshot creation after N operations.
	// Default: 200 operations.
	MaxChangesBeforeSnapshot int

	// MaxSnapshotInterval triggers snapshot creation after N seconds of inactivity.
	// Default: 300 seconds (5 minutes).
	MaxSnapshotInterval int64

	// StorageBackend specifies which storage backend to use.
	// Options: "redis", "memory", "database"
	StorageBackend string

	// RedisAddr specifies Redis server address (if using Redis backend).
	RedisAddr string

	// RedisPassword specifies Redis password (if required).
	RedisPassword string

	// RedisDB specifies Redis database number.
	RedisDB int
}

type HistoryService interface {
	// OnSnapshot handles snapshot events from edit sessions.
	// Called when a new snapshot is created (either by operation count or timeout).
	OnSnapshot(event *HistoryEvent) error

	// OnOperation handles operation events from edit sessions.
	// Called for each OT operation applied to a document.
	OnOperation(event *HistoryEvent) error

	// GetSnapshot retrieves a specific snapshot from storage.
	// Returns the HistoryEvent with content and metadata for the given version.
	GetSnapshot(ctx context.Context, sessionID string, versionID int64) (*HistoryEvent, error)

	// GetSessionHistory retrieves history for a session from storage.
	// Returns up to `limit` most recent events (snapshots and operations).
	GetSessionHistory(ctx context.Context, sessionID string, limit int64) ([]*HistoryEvent, error)

	// ReconstructSnapshot reconstructs the content of a specific version.
	// Necessary when using patch mode, where only the first snapshot has full content.
	// Starting from version 0, applies all patches up to the target version.
	ReconstructSnapshot(ctx context.Context, sessionID string, targetVersionID int64) (string, error)

	// ListSnapshots lists all snapshots for a session.
	// Returns metadata for each snapshot (version, time, creator).
	ListSnapshots(ctx context.Context, sessionID string) ([]*SnapshotInfo, error)

	// Close closes the history service and releases resources.
	Close() error
}

type LegacyMessageType int

type MemoryHistoryService struct {
	// contains filtered or unexported fields
}

type MemoryTransport struct {
	*BaseTransport
	// contains filtered or unexported fields
}

type Message struct {
	Type      LegacyMessageType
	DocID     string
	ClientID  string
	Timestamp int64
	Operation *ot.Operation
	Content   string // For sync messages
	Version   int64  // Document version
	SeqNum    int64  // Sequence number
	Error     string
	Metadata  map[string]interface{}
}

type MessageType string

type MiniRedis struct {
	// contains filtered or unexported fields
}

type MultiDocWebSocketTransport struct {
	// contains filtered or unexported fields
}

type OperationData struct {
	SessionID string      `json:"session_id"` // Edit session UUID
	Revision  int64       `json:"revision"`   // Document version
	Operation interface{} `json:"operation"`  // OT operation: [5, "Hello", 10, -3]
	Selection *CursorData `json:"selection,omitempty"`
}

type PatchManager struct {
	// contains filtered or unexported fields
}

type PatchResult struct {
	Patch      string // Patch in text format (compact)
	PatchSize  int    // Size of patch in bytes
	OldSize    int    // Size of old text in bytes
	NewSize    int    // Size of new text in bytes
	SavedBytes int    // Bytes saved by using patch instead of full content
}

type PatchStats struct {
	TotalDiffs int // Total number of patch operations
}

type ProtocolHandler struct {
	// contains filtered or unexported fields
}

type ProtocolMessage struct {
	Type      MessageType            `json:"type"`
	SessionID string                 `json:"session_id,omitempty"` // Edit session UUID
	Timestamp int64                  `json:"timestamp"`
	Data      json.RawMessage        `json:"data,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

type RedisClient interface {
	// Set stores a key-value pair with optional TTL.
	Set(key string, value interface{}, ttl time.Duration) error

	// Get retrieves a value by key.
	Get(key string) (string, error)

	// LPush adds an element to the left of a list.
	LPush(key string, values ...interface{}) error

	// LRange retrieves a range of elements from a list.
	LRange(key string, start, stop int64) ([]string, error)

	// Publish publishes a message to a channel.
	Publish(channel string, message interface{}) error

	// Close closes the Redis connection.
	Close() error
}

type RedisHistoryService struct {
	// contains filtered or unexported fields
}

type RemoteOperationData struct {
	SessionID string      `json:"session_id"` // Edit session UUID
	ClientID  string      `json:"client_id"`  // Who sent this operation
	Revision  int64       `json:"revision"`   // New document version
	Operation interface{} `json:"operation"`  // OT operation: [5, "Hello", 10, -3]
	Selection *CursorData `json:"selection,omitempty"`
}

type SSEClient struct {
	// contains filtered or unexported fields
}

type SSEServer struct {
	// contains filtered or unexported fields
}

type SSETransport struct {
	*BaseTransport
	// contains filtered or unexported fields
}

type SessionClient struct {
	ClientID  string      // Client ID
	FilePath  string      // File path
	ReadOnly  bool        // Whether client is read-only
	IsEditing bool        // Whether client is actively editing
	Connected bool        // Whether client is connected
	Selection *CursorData // Current cursor/selection
	LastSeen  int64       // Last activity timestamp
}

type SessionInfo struct {
	SessionID         string `json:"session_id"`
	FilePath          string `json:"file_path"`
	Content           string `json:"content"`
	Revision          int64  `json:"revision"`
	SnapshotVersion   int64  `json:"snapshot_version"`
	RecentChangeCount int    `json:"recent_change_count"`
	ReaderCount       int    `json:"reader_count"`
	WriterCount       int    `json:"writer_count"`
	CreatedAt         int64  `json:"created_at"`
	UpdatedAt         int64  `json:"updated_at"`
}

type SessionInfoData struct {
	SessionID   string       `json:"session_id"`
	FilePath    string       `json:"file_path"`
	ReaderCount int          `json:"reader_count"` // Number of read-only subscribers
	WriterCount int          `json:"writer_count"` // Number of editors
	Clients     []ClientInfo `json:"clients"`      // All connected clients
	IsEditing   bool         `json:"is_editing"`   // Whether this file is being edited
}

type SessionManager struct {
	// contains filtered or unexported fields
}

type SessionRefCount struct {
	SessionID   string `json:"session_id"`
	FilePath    string `json:"file_path"`
	ReaderCount int    `json:"reader_count"` // Read-only subscribers
	WriterCount int    `json:"writer_count"` // Active editors
	CreatedAt   int64  `json:"created_at"`
	UpdatedAt   int64  `json:"updated_at"`
}

type SnapshotCreatedData struct {
	SessionID  string        `json:"session_id"` // Edit session UUID
	FilePath   string        `json:"file_path"`  // File path
	VersionID  int64         `json:"version_id"` // Snapshot version ID
	Content    string        `json:"content"`    // Full text content at snapshot
	Operations []interface{} `json:"operations"` // Operations since last snapshot
	CreatedAt  int64         `json:"created_at"` // Creation timestamp
	CreatedBy  string        `json:"created_by"` // Client ID who triggered snapshot
}

type SnapshotData struct {
	SessionID  string       `json:"session_id"` // Edit session UUID
	FilePath   string       `json:"file_path"`
	Content    string       `json:"content"`  // Current document content
	Revision   int64        `json:"revision"` // Current version
	CreatedAt  int64        `json:"created_at"`
	UpdatedAt  int64        `json:"updated_at"`
	Operations interface{}  `json:"operations,omitempty"` // Recent OT operations since last sync
	Clients    []ClientInfo `json:"clients"`              // Other clients in this session
	ReadOnly   bool         `json:"read_only"`            // Whether client has write permission
}

type SnapshotInfo struct {
	SnapshotVersion          int64 `json:"snapshot_version"`
	LastSnapshotTime         int64 `json:"last_snapshot_time"`
	RecentChangeCount        int   `json:"recent_change_count"`
	MaxChangesBeforeSnapshot int   `json:"max_changes_before_snapshot"`
	MaxSnapshotInterval      int64 `json:"max_snapshot_interval"` // seconds
	TimeUntilSnapshot        int64 `json:"time_until_snapshot"`   // seconds
}

type StartEditingData struct {
	FilePath    string `json:"file_path"`
	ContentType string `json:"content_type,omitempty"` // "text", "markdown", etc.
	InitialText string `json:"initial_text,omitempty"` // 如果文件不存在，创建时的初始内容
	ClientID    string `json:"client_id,omitempty"`
}

type StopEditingData struct {
	SessionID string `json:"session_id"` // Edit session UUID
}

type SubscribeData struct {
	FilePath string `json:"file_path"`
	ReadOnly bool   `json:"read_only"` // true = 只读（可用SSE）
	UseSSE   bool   `json:"use_sse"`   // true = 优先使用SSE推送
	ClientID string `json:"client_id,omitempty"`
}

type TCPServer struct {
	// contains filtered or unexported fields
}

type TCPTransport struct {
	*BaseTransport
	// contains filtered or unexported fields
}

type Transport interface {
	// ID returns the unique identifier for this transport.
	ID() string

	// Send sends a message over the transport.
	Send(ctx context.Context, msg *Message) error

	// Receive returns a channel for receiving messages.
	Receive() <-chan *Message

	// Close closes the transport.
	Close() error

	// Connect establishes the connection.
	Connect(ctx context.Context) error

	// IsConnected returns true if the transport is connected.
	IsConnected() bool
}

type TransportError struct {
	Code    string
	Message string
}

type TransportMessageHandler interface {
	// HandleMessage is called when a message is received
	HandleMessage(msg *Message) error
}

type UnsubscribeData struct {
	SessionID string `json:"session_id"` // Edit session UUID
	FilePath  string `json:"file_path,omitempty"`
}

type UserJoinedData struct {
	SessionID string     `json:"session_id"`
	ClientID  string     `json:"client_id"`
	Client    ClientInfo `json:"client"`
}

type UserLeftData struct {
	SessionID string `json:"session_id"`
	ClientID  string `json:"client_id"`
}

type WebSocketConn struct {
	// contains filtered or unexported fields
}

type WebSocketServer struct {
	// contains filtered or unexported fields
}

type WebSocketTransport struct {
	*BaseTransport
	// contains filtered or unexported fields
}

type WelcomeData struct {
	ClientID  string `json:"client_id"`
	ServerID  string `json:"server_id"`
	Timestamp int64  `json:"timestamp"`
}