sdk

type ApplicationHealthStatus int

type ApplicationLiveState struct {
	Resources    []ResourceState
	HealthStatus ApplicationHealthStatus
}

type ApplicationSyncState struct {
	// Status is the sync status of the application.
	Status ApplicationSyncStatus
	// ShortReason is the short reason of the sync status.
	// for example, "The service manifest doesn't be synced"
	ShortReason string
	// Reason is the reason of the sync status.
	// actually, it's the difference between the desired state and the live state.
	Reason string
}

type ApplicationSyncStatus int

type ArtifactKind int

type ArtifactVersion struct {
	// Kind is the kind of the artifact.
	Kind ArtifactKind
	// Version is the version of the artifact.
	Version string
	// Name is the name of the artifact.
	Name string
	// URL is the URL of the artifact.
	URL string
}

type BuildPipelineSyncStagesInput struct {
	// Request is the request to build pipeline sync stages.
	Request BuildPipelineSyncStagesRequest
	// Client is the client to interact with the piped.
	Client *Client
	// Logger is the logger to log the events.
	Logger *zap.Logger
}

type BuildPipelineSyncStagesRequest struct {
	// Rollback indicates whether the stages for rollback are requested.
	Rollback bool
	// Stages contains the stage names and their configurations.
	Stages []StageConfig
}

type BuildPipelineSyncStagesResponse struct {
	Stages []PipelineStage
}

type BuildQuickSyncStagesInput struct {
	// Request is the request to build pipeline sync stages.
	Request BuildQuickSyncStagesRequest
	// Client is the client to interact with the piped.
	Client *Client
	// Logger is the logger to log the events.
	Logger *zap.Logger
}

type BuildQuickSyncStagesRequest struct {
	// Rollback indicates whether the stages for rollback are requested.
	Rollback bool
}

type BuildQuickSyncStagesResponse struct {
	Stages []QuickSyncStage
}

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

type CommandType int32

type ConfigNone = *struct{}

type DeployTarget[Config any] struct {
	// The name of the deploy target.
	Name string `json:"name"`
	// The labes of the deploy target.
	Labels map[string]string `json:"labels,omitempty"`
	// The configuration of the deploy target.
	Config Config `json:"config"`
}

type DeployTargetsNone = []*DeployTarget[struct{}]

type Deployment struct {
	// ID is the unique identifier of the deployment.
	ID string
	// ApplicationID is the unique identifier of the application.
	ApplicationID string
	// ApplicationName is the name of the application.
	ApplicationName string
	// PipedID is the unique identifier of the piped that is running the deployment.
	PipedID string
	// ProjectID is the unique identifier of the project that the application belongs to.
	ProjectID string
	// TriggeredBy is the name of the entity that triggered the deployment.
	TriggeredBy string
	// CreatedAt is the time when the deployment was created.
	CreatedAt int64
}

type DeploymentPlugin[Config, DeployTargetConfig any] interface {
	StagePlugin[Config, DeployTargetConfig]

	// DetermineVersions determines the versions of the resources that will be deployed.
	DetermineVersions(context.Context, *Config, *DetermineVersionsInput) (*DetermineVersionsResponse, error)
	// DetermineStrategy determines the strategy to deploy the resources.
	DetermineStrategy(context.Context, *Config, *DetermineStrategyInput) (*DetermineStrategyResponse, error)
	// BuildQuickSyncStages builds the stages that will be executed during the quick sync process.
	BuildQuickSyncStages(context.Context, *Config, *BuildQuickSyncStagesInput) (*BuildQuickSyncStagesResponse, error)
}

type DeploymentPluginServiceServer[Config, DeployTargetConfig any] struct {
	deployment.UnimplementedDeploymentServiceServer
	// contains filtered or unexported fields
}

type DeploymentSource struct {
	// ApplicationDirectory is the directory where the source code is located.
	ApplicationDirectory string
	// CommitHash is the git commit hash of the source code.
	CommitHash string
	// ApplicationConfig is the configuration of the application.
	ApplicationConfig []byte
	// ApplicationConfigFilename is the name of the file that contains the application configuration.
	// The plugins can use this to avoid mistakenly reading this file as a manifest to deploy.
	ApplicationConfigFilename string
}

type DetermineStrategyInput struct {
	// Request is the request to determine the strategy.
	Request DetermineStrategyRequest
	// Client is the client to interact with the piped.
	Client *Client
	// Logger is the logger to log the events.
	Logger *zap.Logger
}

type DetermineStrategyRequest struct {
	// Deployment is the deployment that the strategy will be determined.
	Deployment Deployment
	// RunningDeploymentSource is the source of the running deployment.
	RunningDeploymentSource DeploymentSource
	// TargetDeploymentSource is the source of the target deployment.
	TargetDeploymentSource DeploymentSource
}

type DetermineStrategyResponse struct {
	// Strategy is the strategy to deploy the resources.
	Strategy SyncStrategy
	// Summary is the summary of the strategy.
	Summary string
}

type DetermineVersionsInput struct {
	// Request is the request to determine versions.
	Request DetermineVersionsRequest
	// Client is the client to interact with the piped.
	Client *Client
	// Logger is the logger to log the events.
	Logger *zap.Logger
}

type DetermineVersionsRequest struct {
	// Deloyment is the deployment that the versions will be determined.
	Deployment Deployment
	// DeploymentSource is the source of the deployment.
	DeploymentSource DeploymentSource
}

type DetermineVersionsResponse struct {
	// Versions contains the versions of the resources.
	Versions []ArtifactVersion
}

type ExecuteStageInput struct {
	// Request is the request to execute a stage.
	Request ExecuteStageRequest
	// Client is the client to interact with the piped.
	Client *Client
	// Logger is the logger to log the events.
	Logger *zap.Logger
}

type ExecuteStageRequest struct {
	// The name of the stage to execute.
	StageName string
	// Json encoded configuration of the stage.
	StageConfig []byte

	// RunningDeploymentSource is the source of the running deployment.
	RunningDeploymentSource DeploymentSource

	// TargetDeploymentSource is the source of the target deployment.
	TargetDeploymentSource DeploymentSource

	// The deployment that the stage is running.
	Deployment Deployment
}

type ExecuteStageResponse struct {
	Status StageStatus
}

type GetLivestateInput struct {
	// Request is the request for getting the live state.
	Request GetLivestateRequest
	// Client is the client for accessing the piped API.
	Client *Client
	// Logger is the logger for logging.
	Logger *zap.Logger
}

type GetLivestateRequest struct {
	// PipedID is the ID of the piped.
	PipedID string
	// ApplicationID is the ID of the application.
	ApplicationID string
	// ApplicationName is the name of the application.
	ApplicationName string
	// DeploymentSource is the source of the deployment.
	DeploymentSource DeploymentSource
}

type GetLivestateResponse struct {
	// LiveState is the live state of the application.
	LiveState ApplicationLiveState
	// SyncState is the sync state of the application.
	SyncState ApplicationSyncState
}

type LivestatePlugin[Config, DeployTargetConfig any] interface {
	Plugin

	// GetLivestate returns the live state of the resources in the given application.
	// It returns the resources' live state and the difference between the desired state and the live state.
	// It's allowed to return only the resources' live state if the difference is not available, or only the difference if the live state is not available.
	GetLivestate(context.Context, *Config, []*DeployTarget[DeployTargetConfig], *GetLivestateInput) (*GetLivestateResponse, error)
}

type LivestatePluginServer[Config, DeployTargetConfig any] struct {
	livestate.UnimplementedLivestateServiceServer
	// contains filtered or unexported fields
}

type ManualOperation int

type PipelineStage struct {
	// Index is the order of the stage in the pipeline.
	// The value must be one of the index of the stage in the request.
	// The rollback stage should have the same index as the original stage.
	Index int
	// Name is the name of the stage.
	// It must be one of the stages returned by FetchDefinedStages.
	Name string
	// Rollback indicates whether the stage is for rollback.
	Rollback bool
	// Metadata contains the metadata of the stage.
	Metadata map[string]string
	// AvailableOperation indicates the manual operation that the user can perform.
	AvailableOperation ManualOperation
}

type Plugin interface {
	// Name returns the name of the plugin.
	Name() string
	// Version returns the version of the plugin.
	Version() string
}

type QuickSyncStage struct {
	// Name is the name of the stage.
	// It must be one of the stages returned by FetchDefinedStages.
	Name string
	// Description is the description of the stage.
	Description string
	// Rollback indicates whether the stage is for rollback.
	Rollback bool
	// Metadata contains the metadata of the stage.
	Metadata map[string]string
	// AvailableOperation indicates the manual operation that the user can perform.
	AvailableOperation ManualOperation
}

type ResourceHealthStatus int

type ResourceState struct {
	// ID is the unique identifier of the resource.
	ID string
	// ParentIDs is the list of the parent resource's IDs.
	ParentIDs []string
	// Name is the name of the resource.
	Name string
	// ResourceType is the type of the resource.
	ResourceType string
	// ResourceMetadata is the metadata of the resource.
	ResourceMetadata map[string]string
	// HealthStatus is the health status of the resource.
	HealthStatus ResourceHealthStatus
	// HealthDescription is the description of the health status.
	HealthDescription string
	// DeployTarget is the target where the resource is deployed.
	DeployTarget string
	// CreatedAt is the time when the resource was created.
	CreatedAt time.Time
}

type StageCommand struct {
	Commander string
	Type      CommandType
}

type StageConfig struct {
	// Index is the order of the stage in the pipeline.
	Index int
	// Name is the name of the stage.
	// It must be one of the stages returned by FetchDefinedStages.
	Name string
	// Config is the configuration of the stage.
	// It should be marshaled to JSON bytes.
	// The plugin should unmarshal it to the appropriate struct.
	Config []byte
}

type StageLogPersister interface {
	Write(log []byte) (int, error)
	Info(log string)
	Infof(format string, a ...interface{})
	Success(log string)
	Successf(format string, a ...interface{})
	Error(log string)
	Errorf(format string, a ...interface{})
}

type StagePlugin[Config, DeployTargetConfig any] interface {
	Plugin

	// FetchDefinedStages returns the list of stages that the plugin can execute.
	FetchDefinedStages() []string
	// BuildPipelineSyncStages builds the stages that will be executed by the plugin.
	BuildPipelineSyncStages(context.Context, *Config, *BuildPipelineSyncStagesInput) (*BuildPipelineSyncStagesResponse, error)
	// ExecuteStage executes the given stage.
	ExecuteStage(context.Context, *Config, []*DeployTarget[DeployTargetConfig], *ExecuteStageInput) (*ExecuteStageResponse, error)
}

type StagePluginServiceServer[Config, DeployTargetConfig any] struct {
	deployment.UnimplementedDeploymentServiceServer
	// contains filtered or unexported fields
}

type StageStatus int

type SyncStrategy int

type TODO struct{}