v1alpha1

type Config struct {
	Template *string `json:"template" yaml:"template" validate:"required,gt=0"` // makes field mandatory and checks if set and non empty
	Dest     *string `json:"dest" yaml:"dest" validate:"required,gt=0"`         // makes field mandatory and checks if set and non empty
}

type Discovery struct {
	Prefix     *string `json:"prefix" yaml:"prefix"`         // no checks needed (TODO: not sure if needed at all, e.g. would it map to a service in k8s)
	Visibility *string `json:"visibility" yaml:"visibility"` // no checks needed (TODO: not sure if needed at all, e.g. would it map to a service in k8s)
}

type Framework struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   FrameworkSpec   `json:"spec,omitempty"`
	Status FrameworkStatus `json:"status,omitempty"`
}

type FrameworkDependency struct {
	//Name specifies the name of the dependency.  Referenced via this in defaults.config
	ReferenceName string `json:"referenceName"`
	corev1.ObjectReference
	//Version captures the requirements for what versions
	// of the above object are allowed
	// Example: ^3.1.4
	Version string `json:"version"`
}

type FrameworkList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Framework `json:"items"`
}

type FrameworkSpec struct {
}

type FrameworkStatus struct {
}

type FrameworkVersion struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   FrameworkVersionSpec   `json:"spec,omitempty"`
	Status FrameworkVersionStatus `json:"status,omitempty"`
}

type FrameworkVersionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []FrameworkVersion `json:"items"`
}

type FrameworkVersionSpec struct {
	// +optional
	Framework corev1.ObjectReference `json:"framework,omitempty"`
	Version   string                 `json:"version,omitempty"`

	//Yaml captures a mustached yaml list of elements that define the application framework instance
	Templates map[string]string   `json:"templates,omitempty"`
	Tasks     map[string]TaskSpec `json:"tasks,omitempty"`

	Parameters []Parameter `json:"parameters,omitempty"`

	//Plans specify a map a plans that specify how to
	Plans map[string]Plan `json:"plans,omitempty"`

	//ConnectionString defines a mustached string that can be used
	// to connect to an instance of the Framework
	// +optional
	ConnectionString string `json:"connectionString,omitempty"`

	Dependencies []FrameworkDependency `json:"dependencies,omitempty"`

	//UpgradableFrom lists all FrameworkVersions that can upgrade to this FrameworkVersion
	UpgradableFrom []FrameworkVersion `json:"upgradableFrom,omitempty"`
}

type FrameworkVersionStatus struct {
}

type HealthCheck struct {
	Cmd *string `json:"cmd" yaml:"cmd" validate:"omitempty,gt=0"` // makes field optional but when set checks if non empty&nil values
	//Interval               int32   `json:"interval" yaml:"interval" validate:"gte=1"`                                 // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
	GracePeriodSecs        int32 `json:"grace-period" yaml:"grace-period" validate:"gte=1"`                         // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
	MaxConsecutiveFailures int32 `json:"max-consecutive-failures" yaml:"max-consecutive-failures" validate:"gte=0"` // makes field optional and checks if its gte 0 (TODO: we should make this a pointer to check if set | can it be zero?)
	DelaySecs              int32 `json:"delay" yaml:"delay" validate:"gte=0"`                                       // makes field optional and checks if its gte 0 (TODO: we should make this a pointer to check if set)
	TimeoutSecs            int32 `json:"timeout" yaml:"timeout" validate:"gte=1"`                                   // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
}

type HostVolume struct {
	HostPath      *string `json:"host-path" yaml:"host-path" validate:"required,gt=0"`           // makes field mandatory and checks if set and non empty (TODO: MatchRegex Custom Validation)
	ContainerPath *string `json:"container-path" yaml:"container-path" validate:"required,gt=0"` // makes field mandatory and checks if set and non empty (TODO: MatchRegex Custom Validation)
}

type Instance struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   InstanceSpec   `json:"spec,omitempty"`
	Status InstanceStatus `json:"status,omitempty"`
}

type InstanceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Instance `json:"items"`
}

type InstanceSpec struct {
	//Framework specifies a reference to a specific Framework object
	FrameworkVersion corev1.ObjectReference `json:"frameworkVersion,omitempty"`
	//Dependency references specific
	Dependencies []FrameworkDependency `json:"dependencies,omitempty"`
	Parameters   map[string]string     `json:"parameters,omitempty"`
}

type InstanceStatus struct {

	//TODO turn into struct
	ActivePlan corev1.ObjectReference `json:"activePlan,omitempty"`
	Status     PhaseState             `json:"status,omitempty"`
}

type Network struct {
	HostPorts      []int32 `json:"host-ports" yaml:"host-ports" validate:"gte=1,dive,gte=1,max=65535"`           // makes field mandatory and checks if its a valid port (TODO: we should make this a pointer to check if set, also check for duplicates)
	ContainerPorts []int32 `json:"container-ports" yaml:"container-ports" validate:"gte=1,dive,gte=1,max=65535"` // makes field mandatory and checks if its a valid port (TODO: we should make this a pointer to check if set, also check for duplicates)
	Labels         string  `json:"labels" yaml:"labels"`                                                         // no checks needed (TODO: not sure if needed at all, e.g. would it map to a service in k8s)
}

type Ordering string

type Parameter struct {
	//DisplayName can be used by UI's looking to
	DisplayName string `json:"displayName,omitempty"`
	//Name is the string that should be used in the mustached file
	// for example, if `name: COUNT`
	// then using the variable in a spec like:
	//
	// spec:
	//   replicas:  {{COUNT}}
	Name string `json:"name,omitempty"`

	//Description captures a longer description of how the variable will be used
	Description string `json:"description,omitempty"`

	//Required specifies if the parameter is required to be provided by all instances, or whether a default can suffice
	Required bool `json:"required,omitempty"`

	//Default is a default value if no paramter is provided by the instance
	Default string `json:"default,omitempty"`

	//Trigger identifies the plan that gets executed when this parameter changes in the Instance object.
	//Default is `update` if present, or `deploy` if not present
	Trigger string `json:"trigger,omitempty"`
}

type Phase struct {
	Name     string   `json:"name"`
	Strategy Ordering `json:"strategy"`
	//Steps maps a step name to a list of mustached kubernetes objects stored as a string
	Steps []Step `json:"steps"`
}

type PhaseState string

type PhaseStatus struct {
	Name     string     `json:"name,omitempty"`
	Strategy Ordering   `json:"strategy,omitempty"`
	State    PhaseState `json:"state,omitempty"`
	//Steps maps a step name to a list of mustached kubernetes objects stored as a string
	Steps []StepStatus `json:"steps"`
}

type Plan struct {
	Strategy Ordering `json:"strategy"`
	//Phases maps a phase name to a Phase object
	Phases []Phase `json:"phases"`
}

type PlanExecution struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   PlanExecutionSpec   `json:"spec,omitempty"`
	Status PlanExecutionStatus `json:"status,omitempty"`
}

type PlanExecutionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []PlanExecution `json:"items"`
}

type PlanExecutionSpec struct {

	// This is copied from the CronJob Spec
	// This flag tells the controller to suspend subsequent executions, it does
	// not apply to already started executions.  Defaults to false.
	// +optional
	Suspend *bool `json:"suspend,omitempty" protobuf:"varint,4,opt,name=suspend"`

	PlanName string                 `json:"planName"`
	Instance corev1.ObjectReference `json:"instance"`
}

type PlanExecutionStatus struct {
	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
	// Important: Run "make" to regenerate code after modifying this file
	Name     string     `json:"name,omitempty"`
	Strategy Ordering   `json:"strategy,omitempty"`
	State    PhaseState `json:"state,omitempty"`
	//Phases maps a phase name to a Phase object
	Phases []PhaseStatus `json:"phases,omitempty"`
}

type Pod struct {
	ResourceSets      map[string]*ResourceSet `json:"resource-sets" yaml:"resource-sets" validate:"gte=0,dive,keys,required,endkeys,required"` // makes field optional but when set it checks for non empty keys and non empty&nil values
	Placement         *string                 `json:"placement" yaml:"placement" validate:"omitempty,gt=0"`                                    // makes field optional but when set checks if non empty&nil values
	Count             int32                   `json:"count" yaml:"count" validate:"gte=1"`                                                     // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
	Image             *string                 `json:"image" yaml:"image" validate:"omitempty,gt=0"`                                            // makes field optional but when set checks if non empty&nil values
	Networks          map[string]*Network     `json:"networks" yaml:"networks" validate:"gte=0,dive,keys,required,endkeys,required"`           // makes field optional but when set it checks for non empty keys and non empty&nil values
	RLimits           map[string]*RLimit      `json:"rlimits" yaml:"rlimits" validate:"gte=0,dive,keys,required,endkeys,required"`             // makes field optional but when set it checks for non empty keys and non empty&nil values
	Uris              []*string               `json:"uris" yaml:"uris" validate:"gte=0,dive,gte=1"`                                            // makes field mandatory and checks if its a valid port (TODO: check for duplicates)
	Tasks             map[string]*Task        `json:"tasks" yaml:"tasks" validate:"required,dive,keys,required,endkeys,required"`              // makes field optional but when set it checks for non empty keys and non empty&nil values
	Volume            *Volume                 `json:"volume" yaml:"volume"`                                                                    // field optional, no need to validate
	Volumes           map[string]*Volume      `json:"volumes" yaml:"volumes" validate:"gte=0,dive,keys,required,endkeys,required"`             // makes field optional but when set it checks for non empty keys and non empty&nil values
	PreReservedRole   *string                 `json:"pre-reserved-role" yaml:"pre-reserved-role" validate:"omitempty,gt=0"`                    // makes field optional but when set checks if non empty&nil values
	Secrets           map[string]*Secret      `json:"secrets" yaml:"secrets" validate:"gte=0,dive,keys,required,endkeys,required"`             // makes field optional but when set it checks for non empty keys and non empty&nil values
	SharePidNamespace bool                    `json:"share-pid-namespace" yaml:"share-pid-namespace"`                                          // no checks needed
	AllowDecommission bool                    `json:"allow-decommission" yaml:"allow-decommission"`                                            // no checks needed
	HostVolumes       map[string]*HostVolume  `json:"host-volumes" yaml:"host-volumes" validate:"gte=0,dive,keys,required,endkeys,required"`   // makes field optional but when set it checks for non empty keys and non empty&nil values
}

type Port struct {
	Port      int32   `json:"port" yaml:"port" validate:"gte=1,max=65535"`      // makes field mandatory and checks if its a valid port (TODO: we should make this a pointer to check if set)
	EnvKey    *string `json:"env-key" yaml:"env-key" validate:"omitempty,gt=0"` // makes field optional but when set checks if non empty&nil values
	Advertise bool    `json:"advertise" yaml:"advertise"`                       // no checks needed (TODO: not sure if needed at all, e.g. would it map to a service in k8s)
	VIP       *VIP    `json:"vip" yaml:"vip"`                                   // no checks needed (TODO: not sure if needed at all, e.g. would it map to a service in k8s)
}

type RLimit struct {
	Soft int64 `json:"soft" yaml:"soft" validate:"gte=1"` // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set | does this apply in k8s land?)
	Hard int64 `json:"hard" yaml:"hard" validate:"gte=1"` // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set | does this apply in k8s land?)
}

type ReadinessCheck struct {
	Cmd          *string `json:"cmd" yaml:"cmd" validate:"omitempty,gt=0"`  // makes field optional but when set checks if non empty&nil values
	IntervalSecs int32   `json:"interval" yaml:"interval" validate:"gte=1"` // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
	DelaySecs    int32   `json:"delay" yaml:"delay" validate:"gte=0"`       // makes field optional and checks if its gte 0 (TODO: we should make this a pointer to check if set)
	TimeoutSecs  int32   `json:"timeout" yaml:"timeout" validate:"gte=1"`   // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)
}

type ResourceSet struct {
	Cpus     float64            `json:"cpus" yaml:"cpus" validate:"omitempty,gt=0"`                                  // makes field optional but if set value needs to be gt 0 (TODO: we should make this a pointer to check if set)
	Gpus     float64            `json:"gpus" yaml:"gpus" validate:"omitempty,gt=0"`                                  // makes field optional but if set value needs to be gt 0 (TODO: we should make this a pointer to check if set)
	MemoryMB int32              `json:"memory" yaml:"memory" validate:"omitempty,gte=1"`                             // makes field optional but if set value needs to be gte 1 (TODO: we should make this a pointer to check if set)
	Ports    map[string]*Port   `json:"ports" yaml:"ports" validate:"gte=0,dive,keys,required,endkeys,required"`     // makes field optional but when set it checks for non empty keys and non empty&nil values
	Volume   *Volume            `json:"volume" yaml:"volume"`                                                        // field optional, no need to validate
	Volumes  map[string]*Volume `json:"volumes" yaml:"volumes" validate:"gte=0,dive,keys,required,endkeys,required"` // makes field optional but when set it checks for non empty keys and non empty&nil values
}

type Scheduler struct {
	Principal *string `json:"principal" yaml:"principal" validate:"omitempty,gt=0"` // makes field optional but when set checks if non empty&nil values
	Zookeeper *string `json:"zookeeper" yaml:"zookeeper" validate:"omitempty,gt=0"` // makes field optional but when set checks if non empty&nil values
	User      *string `json:"user" yaml:"user" validate:"omitempty,gt=0"`           // makes field optional but when set checks if non empty&nil values
}

type Secret struct {
	SecretPath *string `json:"secret" yaml:"secret" validate:"required,gt=0"`    // makes field mandatory and checks if set and non empty
	EnvKey     *string `json:"env-key" yaml:"env-key" validate:"omitempty,gt=0"` // makes field optional but when set checks if non empty&nil values
	FilePath   *string `json:"file" yaml:"file" validate:"omitempty,gt=0"`       // makes field optional but when set checks if non empty&nil values (TODO: MatchRegex Custom Validation)
}

type ServiceSpec struct {
	Name      *string          `json:"name" yaml:"name" validate:"required,gt=0"`                              // makes field mandatory and checks if set and non empty
	WebUrl    *string          `json:"web-url" yaml:"web-url" validate:"required,gt=0"`                        // makes field mandatory and checks if set and non empty
	Scheduler *Scheduler       `json:"scheduler" yaml:"scheduler"`                                             // field optional, no need to validate
	Pods      map[string]*Pod  `json:"pods" yaml:"pods" validate:"gt=0,dive,keys,required,endkeys,required"`   // makes field mandatory but when set it checks for non empty keys and non empty&nil values
	Plans     map[string]*Plan `json:"plans" yaml:"plans" validate:"gt=0,dive,keys,required,endkeys,required"` // makes field mandatory but when set it checks for non empty keys and non empty&nil values
}

type Step struct {
	Name   string   `json:"name"`
	Tasks  []string `json:"tasks"`
	Delete bool     `json:"delete,omitempty"`
	//Objects will be serialized for each instance as the params and defaults
	// are provided
	Objects []runtime.Object `json:"-"`
}

type StepStatus struct {
	Name   string     `json:"name,omitempty"`
	State  PhaseState `json:"state,omitempty"`
	Delete bool       `json:"delete,omitempty"`
	//Objects will be serialized for each instance as the params and defaults
	// are provided, but not serialized in the payload
	Objects []runtime.Object `json:"-"`
}

type Task struct {
	Goal                    *string                `json:"goal" yaml:"goal" validate:"required,gt=0,eq=RUNNING|eq=FINISH|eq=ONCE"`          // makes field mandatory and checks if set and non empty, allows just RUNNING,FINISH,ONCE
	Essential               bool                   `json:"essential" yaml:"essential" validate:"isdefault"`                                 // makes field optional but if set it expects it to be false and will fail if true (TODO: we should make this a pointer to check if set)
	Cmd                     *string                `json:"cmd" yaml:"cmd" validate:"required,gt=0"`                                         // makes field mandatory and checks if set and non empty
	Env                     map[string]*string     `json:"env" yaml:"env" validate:"gte=0,dive,keys,required,endkeys,required"`             // makes field optional but when set it checks for non empty keys and non empty&nil values
	Configs                 map[string]*Config     `json:"configs" yaml:"configs" validate:"gte=0,dive,keys,required,endkeys,required"`     // makes field optional but when set it checks for non empty keys and non empty&nil values
	Cpus                    float64                `json:"cpus" yaml:"cpus" validate:"omitempty,gt=0"`                                      // makes field optional but if set value needs to be gt 0 (TODO: we should make this a pointer to check if set)
	Gpus                    float64                `json:"gpus" yaml:"gpus" validate:"omitempty,gt=0"`                                      // makes field optional but if set value needs to be gt 0 (TODO: we should make this a pointer to check if set)
	MemoryMB                float64                `json:"memory" yaml:"memory" validate:"omitempty,gte=1"`                                 // makes field optional but if set value needs to be gte 1 (TODO: we should make this a pointer to check if set)
	Ports                   map[string]*Port       `json:"ports" yaml:"ports" validate:"gte=0,dive,keys,required,endkeys,required"`         // makes field optional but when set it checks for non empty keys and non empty&nil values
	HealthCheck             *HealthCheck           `json:"health-check" yaml:"health-check"`                                                // field optional, no need to validate
	ReadinessCheck          *ReadinessCheck        `json:"readiness-check" yaml:"readiness-check"`                                          // field optional, no need to validate
	Volume                  *Volume                `json:"volume" yaml:"volume"`                                                            // field optional, no need to validate
	Volumes                 map[string]*Volume     `json:"volumes" yaml:"volumes" validate:"gte=0,dive,keys,required,endkeys,required"`     // makes field optional but when set it checks for non empty keys and non empty&nil values
	ResourceSet             *string                `json:"resource-set" yaml:"resource-set" validate:"omitempty,gt=0"`                      // makes field optional but when set checks if non empty&nil values
	Discovery               *Discovery             `json:"discovery" yaml:"discovery"`                                                      // field optional, no need to validate
	TaskKillGracePeriodSecs int32                  `json:"kill-grace-period" yaml:"kill-grace-period" validate:"gte=0"`                     // makes field optional and checks if its gte 0 (TODO: we should make this a pointer to check if set)
	TransportEncryption     []*TransportEncryption `json:"transport-encryption" yaml:"transport-encryption" validate:"omitempty,gt=0,dive"` // makes field optional and checks if its gt 0
}

type TaskSpec struct {
	Resources []string `json:"resources"`
}

type TransportEncryption struct {
	Name *string `json:"name" yaml:"name" validate:"required,gt=0"`                    // makes field mandatory and checks if set and non empty
	Type *string `json:"type" yaml:"type" validate:"required,gt=0,eq=TLS|eq=KEYSTORE"` // makes field mandatory and checks if set and non empty, allows just TLS or KEYSTORE
}

type VIP struct {
	Port   int32   `json:"port" yaml:"port"`
	Prefix *string `json:"prefix" yaml:"prefix"`
}

type Volume struct {
	Path   *string `json:"path" yaml:"path" validate:"required,gt=0"`                  // makes field mandatory and checks if set and non empty (TODO: MatchRegex Custom Validation)
	Type   *string `json:"type" yaml:"type" validate:"required,gt=0,eq=ROOT|eq=MOUNT"` // makes field mandatory and checks if set and non empty, allows just ROOT or MOUNT
	SizeMB int32   `json:"size" yaml:"size" validate:"gte=1"`                          // makes field mandatory and checks if its gte 1 (TODO: we should make this a pointer to check if set)`
}