gitops

var Environment = Kind{
	Name:     "environment",
	ReadOnly: environment.ReadOnly,
	Identity: "id",

	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		if id := str(local, "id"); id != "" {
			return byID(func(ctx context.Context, c *platform.Client, id openapi_types.UUID) (*http.Response, error) {
				return c.GetEnvironment(ctx, id)
			})(ctx, c, local)
		}
		name := str(local, "name")
		if name == "" {
			return "", nil, nil
		}
		var list struct {
			Environments []struct {
				ID   string `json:"id"`
				Name string `json:"name"`
			} `json:"environments"`
		}
		resp, err := c.GetEnvironments(ctx, &api.GetEnvironmentsParams{Search: &name})
		if _, err := platform.Decode(resp, err, &list); err != nil {
			return "", nil, err
		}
		for _, e := range list.Environments {
			if e.Name == name {
				u, _ := uuid(e.ID)
				remote, err := fetch(c.GetEnvironment(ctx, u))
				return e.ID, remote, err
			}
		}
		return "", nil, nil
	},
}

var ErrDifferent = errors.New("files differ from the platform")

var Experiment = Kind{
	Name:     "experiment",
	ReadOnly: []string{"version", "created", "createdBy", "edited", "editedBy"},
	Identity: "key",

	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		key := str(local, "key")
		if key == "" {
			externalID := str(local, "externalId")
			if externalID == "" {
				return "", nil, nil
			}
			var list struct {
				Experiments []struct {
					Key string `json:"key"`
				} `json:"experiments"`
			}
			ids := []string{externalID}
			resp, err := c.GetExperiments(ctx, &api.GetExperimentsParams{ExternalId: &ids})
			if _, err := platform.Decode(resp, err, &list); err != nil {
				return "", nil, err
			}
			if len(list.Experiments) == 0 {
				return "", nil, nil
			}
			key = list.Experiments[0].Key
		}
		remote, err := fetch(c.GetExperiment(ctx, key))
		return key, remote, err
	},
}

var Hub = Kind{
	Name:     "hub",
	ReadOnly: hub.ReadOnly,
	Identity: "id",
	Remote: byID(func(ctx context.Context, c *platform.Client, id openapi_types.UUID) (*http.Response, error) {
		return c.GetHubById(ctx, id)
	}),
}

var Integrations = map[string]Kind{
	integration.Webhook.Name:         integrationKind(integration.Webhook, "webhook integration", allTargetAttributes),
	integration.Slack.Name:           integrationKind(integration.Slack, "Slack integration", nil),
	integration.Preflight.Name:       integrationKind(integration.Preflight, "preflight webhook", allTargetAttributes),
	integration.PreflightAction.Name: integrationKind(integration.PreflightAction, "preflight action integration", nil),
}

var PropertyDefinition = Kind{
	Name:     "property definition",
	ReadOnly: property.ReadOnly,
	Identity: "key",
	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		key := str(local, "key")
		if key == "" {
			return "", nil, nil
		}
		remote, err := fetch(c.GetPropertyDefinition(ctx, key))
		return key, remote, err
	},
}

var Schedule = Kind{
	Name:     "experiment schedule",
	ReadOnly: []string{"editedBy", "lastUpdated", "nextExecution"},
	Defaults: map[string]any{"allowParallel": true},
	Identity: "id",
	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		id := str(local, "id")
		if id == "" {
			return "", nil, nil
		}
		remote, err := fetch(c.GetSchedules(ctx, id))
		return id, remote, err
	},
}

var Service = Kind{
	Name:     "service",
	ReadOnly: []string{"version", "created", "createdBy", "edited", "editedBy"},
	Defaults: map[string]any{"logoId": "service", "logoColor": "blue"},
	Identity: "id",
	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		id := str(local, "id")
		u, ok := uuid(id)
		if !ok {
			return "", nil, nil
		}
		remote, err := fetch(c.GetService(ctx, u))
		return id, remote, err
	},
}

var ServiceProfile = Kind{
	Name:     "service profile",
	ReadOnly: []string{"version", "created", "createdBy", "edited", "editedBy", "defaultProfile"},
	Defaults: map[string]any{"origin": "CUSTOM"},
	Identity: "id",

	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		id := str(local, "id")
		if u, ok := uuid(id); ok {
			remote, err := fetch(c.GetProfile(ctx, u))
			return id, remote, err
		}
		name := str(local, "name")
		if name == "" {
			return "", nil, nil
		}
		type profile struct {
			ID   string `json:"id"`
			Name string `json:"name"`
		}
		profiles, err := platform.AllPages[profile](func(page, size int32) (*http.Response, error) {
			return c.GetProfiles(ctx, &api.GetProfilesParams{Name: &name, Page: api.PageRequestAO{Page: &page, Size: &size}})
		})
		if err != nil {
			return "", nil, err
		}
		for _, p := range profiles {
			if p.Name == name {
				u, _ := uuid(p.ID)
				remote, err := fetch(c.GetProfile(ctx, u))
				return p.ID, remote, err
			}
		}
		return "", nil, nil
	},
}

var Team = Kind{
	Name:     "team",
	ReadOnly: append(append([]string{"id"}, team.ReadOnly...), prefixed("members.", team.MemberReadOnly)...),

	Defaults: map[string]any{"allowedActions": []any{"wait", "service-validation"}, "managedBy": "MANUAL"},
	Identity: "key",
	Remote: func(ctx context.Context, c *platform.Client, local *jsyaml.Map) (string, *jsyaml.Map, error) {
		key := str(local, "key")
		if key == "" {
			return "", nil, nil
		}
		remote, err := fetch(c.GetTeam(ctx, key))
		return key, remote, err
	},
}

var Template = Kind{
	Name:     "experiment template",
	ReadOnly: template.ReadOnly,
	Identity: "id",
	Remote: byID(func(ctx context.Context, c *platform.Client, id openapi_types.UUID) (*http.Response, error) {
		return c.GetExperimentTemplate(ctx, id)
	}),
}