task

type Alert struct {
	Name      string   `bson:"name" json:"name"`           // 告警名称
	Condition string   `bson:"condition" json:"condition"` // 触发条件
	Channels  []string `bson:"channels" json:"channels"`   // 通知渠道
}

type AlertingConfig struct {
	Enabled bool    `bson:"enabled" json:"enabled"`
	Rules   []Alert `bson:"rules" json:"rules"` // 告警规则
}

type AuthConfig struct {
	Type   string         `bson:"type" json:"type"`     // 认证类型 (none, basic, bearer, oauth2, custom)
	Config map[string]any `bson:"config" json:"config"` // 认证配置
}

type Batch struct {
	ID        string    `json:"id"`
	Tasks     []*Task   `json:"tasks"`
	CreatedAt time.Time `json:"created_at"`
	Source    string    `json:"source"`
}

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

type ConfigSource interface {
	Name() string
	Load(ctx context.Context) ([]*TaskConfig, error)
}

type DateStrategy struct {
	Mode       string `bson:"mode" json:"mode"`                                   // 模式: single(单个日期), range(日期范围), custom(自定义)
	Format     string `bson:"format" json:"format"`                               // 日期格式，如 "2006-01-02"
	StartDays  int    `bson:"start_days" json:"start_days"`                       // 起始天数偏移（相对于今天，可为负数）
	EndDays    int    `bson:"end_days" json:"end_days"`                           // 结束天数偏移（相对于今天）
	DayStep    int    `bson:"day_step" json:"day_step"`                           // 步长（默认1，表示每天）
	CustomDays []int  `bson:"custom_days,omitempty" json:"custom_days,omitempty"` // 自定义天数偏移列表
}

type DeduplicationConfig struct {
	Enabled    bool          `json:"enabled"`
	Strategy   string        `json:"strategy"` // url, content, custom
	Fields     []string      `json:"fields"`   // Fields to use for deduplication
	Expiration time.Duration `json:"expiration"`
}

type DefaultSeedExpander struct{}

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

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

type DispatchStrategy string

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

type DispatcherConfig struct {
	QueueType   QueueType
	Strategy    DispatchStrategy
	BatchSize   int
	MaxRetries  int
	Timeout     time.Duration
	RedisClient *redis.Client
	RedisPrefix string
	Logger      *slog.Logger
}

type ErrorHandling struct {
	Strategy      string   `bson:"strategy" json:"strategy"`             // 策略 (retry, skip, fail, notify)
	RetryStrategy string   `bson:"retry_strategy" json:"retry_strategy"` // 重试策略 (exponential, linear, fixed)
	MaxRetries    int      `bson:"max_retries" json:"max_retries"`       // 最大重试次数
	NotifyOn      []string `bson:"notify_on" json:"notify_on"`           // 通知条件
}

type Event struct {
	Type      string                 `json:"type"`
	Source    string                 `json:"source"`
	Data      map[string]interface{} `json:"data"`
	Timestamp time.Time              `json:"timestamp"`
}

type ExecutionConfig struct {
	Mode          string        `bson:"mode" json:"mode"`                     // 执行模式 (single, batch, stream)
	BatchSize     int           `bson:"batch_size" json:"batch_size"`         // 批量大小
	Parallelism   int           `bson:"parallelism" json:"parallelism"`       // 并行度
	Dependencies  []string      `bson:"dependencies" json:"dependencies"`     // 依赖任务
	PreHooks      []HookConfig  `bson:"pre_hooks" json:"pre_hooks"`           // 前置钩子
	PostHooks     []HookConfig  `bson:"post_hooks" json:"post_hooks"`         // 后置钩子
	ErrorHandling ErrorHandling `bson:"error_handling" json:"error_handling"` // 错误处理
}

type Executor interface {
	// Execute executes the task
	Execute(ctx context.Context, task *Task) (*TaskResult, error)

	// SetFetcher sets the fetcher
	SetFetcher(fetcher Fetcher)

	// SetExtractor sets the extractor
	SetExtractor(extractor Extractor)

	// SetPipeline sets the pipeline
	SetPipeline(pipeline Pipeline)

	// SetStorage sets the storage
	SetStorage(storage Storage)
}

type ExtractRule struct {
	Field     string          `json:"field"`
	Selector  string          `json:"selector"`
	Type      string          `json:"type"` // css, xpath, json, regex
	Attribute string          `json:"attribute,omitempty"`
	Multiple  bool            `json:"multiple"`
	Required  bool            `json:"required"`
	Default   interface{}     `json:"default,omitempty"`
	Transform []TransformRule `json:"transform,omitempty"`
	Children  []ExtractRule   `json:"children,omitempty"` // For nested extraction
}

type ExtractionConfig struct {
	Type      string           `bson:"type" json:"type"`           // 提取类型 (json, html, xml, regex, custom)
	Rules     []ExtractionRule `bson:"rules" json:"rules"`         // 提取规则
	Scripts   []Script         `bson:"scripts" json:"scripts"`     // 自定义脚本
	Templates []Template       `bson:"templates" json:"templates"` // 模板
}

type ExtractionRule struct {
	Field      string           `bson:"field" json:"field"`           // 字段名
	Path       string           `bson:"path" json:"path"`             // 路径表达式
	Type       string           `bson:"type" json:"type"`             // 数据类型
	Required   bool             `bson:"required" json:"required"`     // 是否必需
	Default    any              `bson:"default" json:"default"`       // 默认值
	Transform  []Transform      `bson:"transform" json:"transform"`   // 转换规则
	Validation []Validation     `bson:"validation" json:"validation"` // 验证规则
	Children   []ExtractionRule `bson:"children" json:"children"`     // 子规则（嵌套结构）
}

type Extractor interface {
	// Extract extracts data from the response
	Extract(ctx context.Context, response *Response, rules []ExtractRule) (map[string]interface{}, error)

	// ExtractLinks extracts links for further crawling
	ExtractLinks(ctx context.Context, response *Response) ([]string, error)

	// GetType returns the extractor type (css, xpath, json, regex)
	GetType() string
}

type Fetcher interface {
	// Fetch fetches content from the given URL
	Fetch(ctx context.Context, task *Task) (*Response, error)

	// GetType returns the fetcher type (http, browser, api)
	GetType() string
}

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

type HookConfig struct {
	Type   string         `bson:"type" json:"type"`     // 钩子类型 (http, script, function)
	Action string         `bson:"action" json:"action"` // 动作
	Config map[string]any `bson:"config" json:"config"` // 配置
}

type LinkRule struct {
	Name      string      `json:"name"`
	Selector  string      `json:"selector"`
	Type      string      `json:"type"` // css, xpath, regex, json
	Attribute string      `json:"attribute"`
	Pattern   string      `json:"pattern"`   // URL pattern to match
	TaskType  Type        `json:"task_type"` // Type for generated tasks
	Priority  Priority    `json:"priority"`
	Depth     int         `json:"depth"`    // Max depth for this rule
	Metadata  interface{} `json:"metadata"` // Metadata to add to generated tasks
}

type LoaderConfig struct {
	Registry    *TaskRegistry
	Manager     *TaskManager
	Redis       *redis.Client
	Prefix      string
	Logger      *slog.Logger
	ConfigPaths []string
	WatchFiles  bool
}

type LoggingConfig struct {
	Level      string  `bson:"level" json:"level"`             // 日志级别
	SampleRate float64 `bson:"sample_rate" json:"sample_rate"` // 采样率
}

type ManagerConfig struct {
	Registry           *TaskRegistry
	Redis              *redis.Client
	Prefix             string
	Logger             *slog.Logger
	Allocator          TaskAllocator
	NodeManager        NodeManager
	MaxActiveTasks     int
	TaskTimeout        time.Duration
	CleanupInterval    time.Duration
	StateCheckInterval time.Duration
}

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

type MetricsConfig struct {
	Enabled    bool              `bson:"enabled" json:"enabled"`
	Collectors []string          `bson:"collectors" json:"collectors"` // 收集器
	Labels     map[string]string `bson:"labels" json:"labels"`         // 标签
}

type MonitoringConfig struct {
	Metrics  MetricsConfig  `bson:"metrics" json:"metrics"`   // 指标配置
	Logging  LoggingConfig  `bson:"logging" json:"logging"`   // 日志配置
	Alerting AlertingConfig `bson:"alerting" json:"alerting"` // 告警配置
	Tracing  TracingConfig  `bson:"tracing" json:"tracing"`   // 追踪配置
}

type NodeInfo struct {
	ID            string    `json:"id"`
	Address       string    `json:"address"`
	Capacity      int       `json:"capacity"`
	CurrentLoad   int       `json:"current_load"`
	Status        string    `json:"status"`
	LastHeartbeat time.Time `json:"last_heartbeat"`
	Tags          []string  `json:"tags"`
	Capabilities  []string  `json:"capabilities"`
}

type NodeManager interface {
	GetAvailableNodes(ctx context.Context) ([]NodeInfo, error)
	GetNode(ctx context.Context, nodeID string) (*NodeInfo, error)
	UpdateNodeLoad(ctx context.Context, nodeID string, delta int) error
}

type PaginationConfig struct {
	Enabled       bool   `bson:"enabled" json:"enabled"`
	Type          string `bson:"type" json:"type"`                     // 分页类型 (page, offset, cursor, token)
	StartParam    string `bson:"start_param" json:"start_param"`       // 起始参数名
	LimitParam    string `bson:"limit_param" json:"limit_param"`       // 限制参数名
	StartValue    any    `bson:"start_value" json:"start_value"`       // 起始值
	PageSize      int    `bson:"page_size" json:"page_size"`           // 页大小
	MaxPages      int    `bson:"max_pages" json:"max_pages"`           // 最大页数
	StopCondition string `bson:"stop_condition" json:"stop_condition"` // 停止条件
}

type Pipeline interface {
	// Process processes the extracted data through the pipeline
	Process(ctx context.Context, data map[string]interface{}) (map[string]interface{}, error)

	// GetID returns the pipeline identifier
	GetID() string

	// Validate validates the data against pipeline rules
	Validate(data map[string]interface{}) error
}

type Priority int

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

type Processor struct {
	Name   string         `bson:"name" json:"name"`     // 处理器名称
	Type   string         `bson:"type" json:"type"`     // 处理器类型
	Config map[string]any `bson:"config" json:"config"` // 处理器配置
}

type ProxyConfig struct {
	Enabled  bool     `bson:"enabled" json:"enabled"`
	Type     string   `bson:"type" json:"type"` // 代理类型 (http, socks5)
	Rotation bool     `bson:"rotation" json:"rotation"`
	Servers  []string `bson:"servers" json:"servers"`
}

type Queue interface {
	// Push adds a task to the queue
	Push(ctx context.Context, task *Task) error
	// PushBatch adds multiple tasks
	PushBatch(ctx context.Context, tasks []*Task) error
	// Pop retrieves and removes a task from the queue
	Pop(ctx context.Context) (*Task, error)
	// PopN retrieves and removes N tasks from the queue
	PopN(ctx context.Context, n int) ([]*Task, error)
	// Peek retrieves but doesn't remove a task
	Peek(ctx context.Context) (*Task, error)
	// Size returns queue size
	Size(ctx context.Context) (int64, error)
	// Clear removes all tasks
	Clear(ctx context.Context) error
	// Stats returns queue statistics
	Stats(ctx context.Context) (*QueueStats, error)
}

type QueueStats struct {
	Total      int64              `json:"total"`
	ByStatus   map[Status]int64   `json:"by_status"`
	ByPriority map[Priority]int64 `json:"by_priority"`
	ByType     map[Type]int64     `json:"by_type"`
	OldestTask time.Time          `json:"oldest_task"`
	NewestTask time.Time          `json:"newest_task"`
}

type QueueType string

type RateLimitConfig struct {
	Enabled         bool `bson:"enabled" json:"enabled"`
	RequestsPerMin  int  `bson:"requests_per_min" json:"requests_per_min"`
	RequestsPerHour int  `bson:"requests_per_hour" json:"requests_per_hour"`
	BurstSize       int  `bson:"burst_size" json:"burst_size"`
}

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

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

type RequestTemplate struct {
	Method      string            `bson:"method" json:"method"`             // 请求方法
	URL         string            `bson:"url" json:"url"`                   // URL模板（支持变量）
	Headers     map[string]string `bson:"headers" json:"headers"`           // 请求头
	Cookies     map[string]string `bson:"cookies" json:"cookies"`           // Cookies
	QueryParams map[string]any    `bson:"query_params" json:"query_params"` // 查询参数
	Body        any               `bson:"body" json:"body"`                 // 请求体（支持模板）
	Auth        AuthConfig        `bson:"auth" json:"auth"`                 // 认证配置
	Proxy       ProxyConfig       `bson:"proxy" json:"proxy"`               // 代理配置
	Variables   []Variable        `bson:"variables" json:"variables"`       // 变量定义
	Pagination  PaginationConfig  `bson:"pagination" json:"pagination"`     // 分页配置
}

type Response struct {
	StatusCode int
	Headers    map[string][]string
	Body       []byte
	URL        string // Final URL after redirects

	// For browser-based fetching
	HTML       string
	Screenshot []byte

	// Metadata
	Duration int64 // Response time in milliseconds
	Size     int64 // Content size in bytes
}

type RoutingRule struct {
	Name      string
	Condition func(*Task) bool
	Target    string // Node ID or tag
	Priority  int
}

type Schedule struct {
	ID           string                 `json:"id"`
	Name         string                 `json:"name"`
	Type         ScheduleType           `json:"type"`
	Expression   string                 `json:"expression"` // Cron expression or interval
	TaskTemplate *Task                  `json:"task_template"`
	Enabled      bool                   `json:"enabled"`
	LastRun      *time.Time             `json:"last_run,omitempty"`
	NextRun      *time.Time             `json:"next_run,omitempty"`
	RunCount     int                    `json:"run_count"`
	MaxRuns      int                    `json:"max_runs"` // 0 for unlimited
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
	CreatedAt    time.Time              `json:"created_at"`
	UpdatedAt    time.Time              `json:"updated_at"`
}

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

type ScheduleCond struct {
	Type       string `bson:"type" json:"type"`             // 条件类型
	Expression string `bson:"expression" json:"expression"` // 条件表达式
}

type ScheduleConfig struct {
	Type       string         `bson:"type" json:"type"`             // 调度类型 (cron, interval, once, manual)
	Expression string         `bson:"expression" json:"expression"` // Cron表达式或间隔
	Timezone   string         `bson:"timezone" json:"timezone"`     // 时区
	StartTime  *time.Time     `bson:"start_time" json:"start_time"` // 开始时间
	EndTime    *time.Time     `bson:"end_time" json:"end_time"`     // 结束时间
	Conditions []ScheduleCond `bson:"conditions" json:"conditions"` // 执行条件
}

type ScheduleType string

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

type SchedulerConfig struct {
	Dispatcher *Dispatcher
	Logger     *slog.Logger
}

type Script struct {
	Language string `bson:"language" json:"language"` // 脚本语言 (javascript, python, lua)
	Code     string `bson:"code" json:"code"`         // 脚本代码
}

type ScriptConfig struct {
	ID          string                 `json:"id" yaml:"id"`
	Name        string                 `json:"name" yaml:"name"`
	Description string                 `json:"description" yaml:"description"`
	Language    string                 `json:"language" yaml:"language"` // lua, javascript
	Source      string                 `json:"source" yaml:"source"`     // inline, file, url
	Content     string                 `json:"content" yaml:"content"`
	File        string                 `json:"file" yaml:"file"`
	URL         string                 `json:"url" yaml:"url"`
	Parameters  map[string]interface{} `json:"parameters" yaml:"parameters"`
	Schedule    string                 `json:"schedule" yaml:"schedule"` // Cron expression
}

type SeedExpander interface {
	Expand(data []byte) []*Task
}

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

type Status string

type Storage interface {
	// Save saves the processed data
	Save(ctx context.Context, data interface{}) error

	// SaveBatch saves multiple items
	SaveBatch(ctx context.Context, items []interface{}) error

	// GetType returns the storage type (mongodb, mysql, redis, file, etc.)
	GetType() string

	// Close closes the storage connection
	Close() error
}

type StorageConfig struct {
	Type       string `json:"type"` // mongodb, mysql, redis, file, s3
	Database   string `json:"database,omitempty"`
	Collection string `json:"collection,omitempty"` // For MongoDB
	Table      string `json:"table,omitempty"`      // For SQL databases
	Bucket     string `json:"bucket,omitempty"`     // For S3
	Path       string `json:"path,omitempty"`       // For file storage
	Format     string `json:"format,omitempty"`     // json, csv, parquet

	// Additional configuration
	Options map[string]interface{} `json:"options,omitempty"`
}

type StorageConfiguration struct {
	Targets []StorageTarget `bson:"targets" json:"targets"` // 存储目标
}

type StorageTarget struct {
	Name       string         `bson:"name" json:"name"`             // 目标名称
	Type       string         `bson:"type" json:"type"`             // 存储类型 (mongodb, mysql, redis, elasticsearch, file, s3)
	Purpose    string         `bson:"purpose" json:"purpose"`       // 用途 (primary, backup, cache, archive)
	Config     map[string]any `bson:"config" json:"config"`         // 存储配置
	Conditions []string       `bson:"conditions" json:"conditions"` // 存储条件
}

type Task struct {
	// Identity
	ID       string `json:"id"`
	ParentID string `json:"parent_id,omitempty"` // MongoDB task ID
	Name     string `json:"name,omitempty"`      // Task name from MongoDB
	URL      string `json:"url"`
	Hash     string `json:"hash"` // URL hash for deduplication
	Type     string `json:"type"` // Changed to string for flexibility
	Priority int    `json:"priority"`
	Status   Status `json:"status"`
	NodeID   string `json:"node_id,omitempty"` // Assigned node

	// Retry management
	RetryCount int           `json:"retry_count"`
	MaxRetries int           `json:"max_retries"`
	RetryDelay time.Duration `json:"retry_delay"`
	LastError  string        `json:"last_error,omitempty"`

	// Timing
	CreatedAt   time.Time  `json:"created_at"`
	QueuedAt    *time.Time `json:"queued_at,omitempty"`
	StartedAt   *time.Time `json:"started_at,omitempty"`
	CompletedAt *time.Time `json:"completed_at,omitempty"`
	ExpiresAt   *time.Time `json:"expires_at,omitempty"`

	// Configuration
	Method         string            `json:"method"` // GET, POST, etc.
	Headers        map[string]string `json:"headers,omitempty"`
	Body           []byte            `json:"body,omitempty"`
	Cookies        map[string]string `json:"cookies,omitempty"`
	Proxy          string            `json:"proxy,omitempty"`
	UserAgent      string            `json:"user_agent,omitempty"`
	Timeout        time.Duration     `json:"timeout"`
	FollowRedirect bool              `json:"follow_redirect"`

	// Data extraction
	ExtractRules []ExtractRule `json:"extract_rules,omitempty"`
	Pipeline     Pipeline      `json:"-"`                        // Pipeline interface (not serialized)
	PipelineID   string        `json:"pipeline_id,omitempty"`    // Pipeline identifier for reconstruction
	Storage      Storage       `json:"-"`                        // Storage interface (not serialized)
	StorageConf  StorageConfig `json:"storage_config,omitempty"` // Storage configuration

	// Metadata
	Metadata map[string]interface{} `json:"metadata,omitempty"`
	Tags     []string               `json:"tags,omitempty"`
	Depth    int                    `json:"depth"`            // Crawl depth from seed
	Source   string                 `json:"source,omitempty"` // Source identifier

	// Lua script support
	ProjectID string `json:"project_id,omitempty"` // Project identifier for Lua scripts
	LuaScript string `json:"lua_script,omitempty"` // Lua script name (not path)

	// Callbacks
	OnSuccess  string `json:"on_success,omitempty"`  // Webhook or queue for success
	OnFailure  string `json:"on_failure,omitempty"`  // Webhook or queue for failure
	OnComplete string `json:"on_complete,omitempty"` // Webhook or queue for completion
}

type TaskAllocator interface {
	Allocate(ctx context.Context, instance *TaskInstance, nodes []NodeInfo) (*NodeInfo, error)
	Release(ctx context.Context, instance *TaskInstance) error
}

type TaskConfig struct {
	Type       string                 `json:"type" yaml:"type"` // definition, template, script
	Definition *TaskDef               `json:"definition" yaml:"definition"`
	Template   *TaskTemplate          `json:"template" yaml:"template"`
	Script     *ScriptConfig          `json:"script" yaml:"script"`
	Metadata   map[string]interface{} `json:"metadata" yaml:"metadata"`
}

type TaskConfiguration struct {
	Priority    int             `bson:"priority" json:"priority"`       // 优先级 (1-10)
	Timeout     int             `bson:"timeout" json:"timeout"`         // 超时时间（秒）
	MaxRetries  int             `bson:"max_retries" json:"max_retries"` // 最大重试次数
	RetryDelay  int             `bson:"retry_delay" json:"retry_delay"` // 重试延迟（秒）
	Concurrency int             `bson:"concurrency" json:"concurrency"` // 并发数
	RateLimit   RateLimitConfig `bson:"rate_limit" json:"rate_limit"`   // 速率限制
	Parameters  map[string]any  `bson:"parameters" json:"parameters"`   // 自定义参数
}

type TaskDef struct {
	// Basic info
	ID          string `json:"id"`
	Name        string `json:"name"`
	Version     string `json:"version"`
	Description string `json:"description"`
	Author      string `json:"author"`
	Category    string `json:"category"` // seed, page, api, browser

	// Task type
	Type     Type     `json:"type"`
	Priority Priority `json:"priority"`

	// Request configuration
	Method         string            `json:"method"`
	Headers        map[string]string `json:"headers"`
	DefaultTimeout time.Duration     `json:"default_timeout"`
	MaxRetries     int               `json:"max_retries"`
	RetryInterval  time.Duration     `json:"retry_interval"`

	// Extraction rules
	ExtractRules []ExtractRule `json:"extract_rules"`
	LinkRules    []LinkRule    `json:"link_rules"` // For generating child tasks

	// Processing
	Pipeline      string              `json:"pipeline"`   // Pipeline configuration name
	Processors    []string            `json:"processors"` // Processor names
	Storage       string              `json:"storage"`    // Storage configuration name
	Deduplication DeduplicationConfig `json:"deduplication"`

	// Validation
	Validator TaskValidator `json:"-"`
	Schema    interface{}   `json:"schema"` // JSON schema for validation

	// Hooks
	Hooks TaskHooks `json:"-"`

	// Tags and metadata
	Tags     []string               `json:"tags"`
	Labels   map[string]string      `json:"labels"`
	Metadata map[string]interface{} `json:"metadata"`

	// Status
	Active    bool      `json:"active"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type TaskDocument struct {
	ID          primitive.ObjectID   `bson:"_id,omitempty" json:"id"`
	Name        string               `bson:"name" json:"name"`               // 任务名称
	Type        string               `bson:"type" json:"type"`               // 任务类型 (http, api, websocket, custom)
	Category    string               `bson:"category" json:"category"`       // 任务分类 (sports, news, e-commerce, etc)
	Description string               `bson:"description" json:"description"` // 任务描述
	Version     string               `bson:"version" json:"version"`         // 任务版本
	Status      TaskStatus           `bson:"status" json:"status"`           // 任务状态
	Config      TaskConfiguration    `bson:"config" json:"config"`           // 通用配置
	Schedule    ScheduleConfig       `bson:"schedule" json:"schedule"`       // 调度配置
	Execution   ExecutionConfig      `bson:"execution" json:"execution"`     // 执行配置
	Request     RequestTemplate      `bson:"request" json:"request"`         // 请求模板
	Extraction  ExtractionConfig     `bson:"extraction" json:"extraction"`   // 数据提取配置
	Transform   TransformConfig      `bson:"transform" json:"transform"`     // 数据转换配置
	Validation  ValidationConfig     `bson:"validation" json:"validation"`   // 数据验证配置
	Storage     StorageConfiguration `bson:"storage" json:"storage"`         // 存储配置
	Monitoring  MonitoringConfig     `bson:"monitoring" json:"monitoring"`   // 监控配置
	Metadata    map[string]any       `bson:"metadata" json:"metadata"`       // 元数据
	Tags        []string             `bson:"tags" json:"tags"`               // 标签

	// Lua脚本相关配置
	ProjectID string `bson:"project_id" json:"project_id"` // 项目ID（用于数据分组）
	LuaScript string `bson:"lua_script" json:"lua_script"` // Lua脚本名称标识（如: drip_ground_board）

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
	CreatedBy string    `bson:"created_by" json:"created_by"`
	UpdatedBy string    `bson:"updated_by" json:"updated_by"`
}

type TaskFilter struct {
	Type     string
	Category string
	Enabled  *bool
	Tags     []string
	SortBy   string
	SortDesc bool
	Limit    int
	Offset   int
}

type TaskHooks struct {
	BeforeExecute func(ctx context.Context, task *Task) error
	AfterExecute  func(ctx context.Context, task *Task, result interface{}) error
	OnSuccess     func(ctx context.Context, task *Task, data interface{}) error
	OnFailure     func(ctx context.Context, task *Task, err error) error
	OnRetry       func(ctx context.Context, task *Task, attempt int) error
}

type TaskInstance struct {
	ID           string    `json:"id"`
	DefinitionID string    `json:"definition_id"`
	Task         *Task     `json:"task"`
	State        TaskState `json:"state"`
	NodeID       string    `json:"node_id"`
	WorkerID     string    `json:"worker_id"`

	// Context
	Context   map[string]interface{} `json:"context"`
	Variables map[string]interface{} `json:"variables"`

	// Timing
	CreatedAt   time.Time  `json:"created_at"`
	StartedAt   *time.Time `json:"started_at"`
	CompletedAt *time.Time `json:"completed_at"`

	// Results
	Result     interface{} `json:"result"`
	Error      string      `json:"error"`
	RetryCount int         `json:"retry_count"`

	// Dependencies
	Dependencies []string `json:"dependencies"`
	DependsOn    []string `json:"depends_on"`

	// Monitoring
	LastHeartbeat time.Time              `json:"last_heartbeat"`
	Progress      float64                `json:"progress"`
	Metrics       map[string]interface{} `json:"metrics"`
}

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

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

type TaskResult struct {
	TaskID  string                 `json:"task_id"`
	Status  string                 `json:"status"`
	Message string                 `json:"message,omitempty"`
	Data    map[string]interface{} `json:"data,omitempty"`
	Links   []string               `json:"links,omitempty"`
	Error   string                 `json:"error,omitempty"`

	// Metrics
	StartTime      int64 `json:"start_time"`
	EndTime        int64 `json:"end_time"`
	Duration       int64 `json:"duration"` // in milliseconds
	BytesFetched   int64 `json:"bytes_fetched"`
	ItemsExtracted int   `json:"items_extracted"`
}

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

type TaskScheduler interface {
	// AddTask adds a task to the scheduler
	AddTask(task *Task) error

	// GetNextTask gets the next task to execute
	GetNextTask() (*Task, error)

	// UpdateTask updates task status
	UpdateTask(task *Task) error

	// GetStats returns scheduler statistics
	GetStats() map[string]interface{}
}

type TaskState string

type TaskStatus struct {
	Enabled      bool      `bson:"enabled" json:"enabled"`             // 是否启用
	LastRun      time.Time `bson:"last_run" json:"last_run"`           // 最后运行时间
	NextRun      time.Time `bson:"next_run" json:"next_run"`           // 下次运行时间
	RunCount     int64     `bson:"run_count" json:"run_count"`         // 运行次数
	SuccessCount int64     `bson:"success_count" json:"success_count"` // 成功次数
	FailureCount int64     `bson:"failure_count" json:"failure_count"` // 失败次数
	LastSuccess  time.Time `bson:"last_success" json:"last_success"`   // 最后成功时间
	LastFailure  time.Time `bson:"last_failure" json:"last_failure"`   // 最后失败时间
	ErrorMessage string    `bson:"error_message" json:"error_message"` // 错误信息
}

type TaskTemplate struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
	Definition  string `json:"definition"` // Definition ID

	// URL generation
	URLPattern string                 `json:"url_pattern"`
	URLParams  map[string]interface{} `json:"url_params"`

	// Overrides
	Headers    map[string]string      `json:"headers"`
	Metadata   map[string]interface{} `json:"metadata"`
	Priority   *Priority              `json:"priority"`
	MaxRetries *int                   `json:"max_retries"`

	// Schedule
	Schedule string `json:"schedule"` // Cron expression
	Enabled  bool   `json:"enabled"`

	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type TaskValidator interface {
	Validate(task *Task) error
	ValidateData(data map[string]interface{}) error
}

type Template struct {
	Name    string `bson:"name" json:"name"`       // 模板名称
	Content string `bson:"content" json:"content"` // 模板内容
}

type TracingConfig struct {
	Enabled     bool    `bson:"enabled" json:"enabled"`
	SampleRate  float64 `bson:"sample_rate" json:"sample_rate"`
	ServiceName string  `bson:"service_name" json:"service_name"`
}

type Transform struct {
	Type   string         `bson:"type" json:"type"`     // 转换类型
	Config map[string]any `bson:"config" json:"config"` // 转换配置
}

type TransformConfig struct {
	Enabled    bool        `bson:"enabled" json:"enabled"`
	Processors []Processor `bson:"processors" json:"processors"` // 处理器链
}

type TransformRule struct {
	Type   string                 `json:"type"` // trim, replace, regex, format, split, join
	Params map[string]interface{} `json:"params,omitempty"`
}

type Type string

type Validation struct {
	Type    string `bson:"type" json:"type"`       // 验证类型
	Field   string `bson:"field" json:"field"`     // 字段
	Rule    string `bson:"rule" json:"rule"`       // 规则表达式
	Message string `bson:"message" json:"message"` // 错误消息
}

type ValidationConfig struct {
	Enabled bool         `bson:"enabled" json:"enabled"`
	Rules   []Validation `bson:"rules" json:"rules"` // 验证规则
}

type Variable struct {
	Name       string        `bson:"name" json:"name"`                             // 变量名
	Type       string        `bson:"type" json:"type"`                             // 类型 (string, number, date, array)
	Source     string        `bson:"source" json:"source"`                         // 来源 (env, context, function, static)
	Expression string        `bson:"expression" json:"expression"`                 // 表达式
	Default    any           `bson:"default" json:"default"`                       // 默认值
	Strategy   *DateStrategy `bson:"strategy,omitempty" json:"strategy,omitempty"` // 日期策略（仅当Type为date时使用）
}

type Writer interface {
	io.Writer
	io.Closer

	// WriteRecord writes a single record
	WriteRecord(record interface{}) error

	// WriteBatch writes multiple records
	WriteBatch(records []interface{}) error

	// Flush flushes any buffered data
	Flush() error
}