elasti_cache

var CacheCluster = Resource{
	AwsType: "AWS::ElastiCache::CacheCluster",

	Attributes: map[string]Schema{
		"ConfigurationEndpoint.Address": Schema{
			Type: ValueString,
		},

		"ConfigurationEndpoint.Port": Schema{
			Type: ValueString,
		},
	},

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"AutoMinorVersionUpgrade": Schema{
			Type: ValueBool,
		},

		"AZMode": Schema{
			Type:         azMode,
			ValidateFunc: azModeValidate,
			Default:      "single-az",
		},

		"CacheNodeType": Schema{
			Type:     cacheNodeType,
			Required: constraints.Always,
		},

		"CacheParameterGroupName": Schema{
			Type: ValueString,
		},

		"CacheSecurityGroupNames": Schema{
			Type:      Multiple(cacheSecurityGroupName),
			Conflicts: constraints.PropertyExists("VpcSecurityGroupIds"),
		},

		"CacheSubnetGroupName": Schema{
			Type: cacheSubnetGroupName,
		},

		"ClusterName": Schema{
			Type: ValueString,
		},

		"Engine": Schema{
			Type:     engine,
			Required: constraints.Always,
		},

		"EngineVersion": Schema{
			Type: ValueString,
		},

		"NotificationTopicArn": Schema{
			Type: ARN,
		},

		"NumCacheNodes": Schema{
			Type:         ValueNumber,
			Required:     constraints.Always,
			ValidateFunc: numCacheNodesValidate,
		},

		"Port": Schema{
			Type: ValueNumber,
		},

		"PreferredAvailabilityZone": Schema{
			Type: AvailabilityZone,
		},

		"PreferredAvailabilityZones": Schema{
			Type:     Multiple(AvailabilityZone),
			Required: constraints.PropertyIs("AZMode", "cross-az"),
		},

		"PreferredMaintenanceWindow": Schema{
			Type: ValueString,
		},

		"SnapshotArns": Schema{
			Type: Multiple(ARN),
		},

		"SnapshotName": Schema{
			Type: ValueString,
		},

		"SnapshotRetentionLimit": Schema{
			Type: ValueNumber,
		},

		"SnapshotWindow": Schema{
			Type: ValueString,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpcSecurityGroupIds": Schema{
			Type:      Multiple(SecurityGroupID),
			Conflicts: constraints.PropertyExists("CacheSecurityGroupNames"),
		},
	},
}

var ParameterGroup = Resource{
	AwsType: "AWS::ElastiCache::ParameterGroup",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"CacheParameterGroupFamily": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"Description": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"Properties": Schema{
			Type:     JSON,
			Required: constraints.Always,
		},
	},
}

var ReplicationGroup = Resource{
	AwsType: "AWS::ElastiCache::ReplicationGroup",

	Attributes: map[string]Schema{
		"PrimaryEndPoint.Address": Schema{
			Type: ValueString,
		},

		"PrimaryEndPoint.Port": Schema{
			Type: ValueNumber,
		},

		"ReadEndPoint.Addresses": Schema{
			Type: ValueString,
		},

		"ReadEndPoint.Ports": Schema{
			Type: ValueString,
		},

		"ReadEndPoint.Addresses.List": Schema{
			Type: Multiple(ValueString),
		},

		"ReadEndPoint.Ports.List": Schema{
			Type: Multiple(ValueNumber),
		},
	},

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"AutomaticFailoverEnabled": Schema{
			Type:    ValueBool,
			Default: true,

			ValidateFunc: automaticFailoverEnabledValidation,
		},

		"AutoMinorVersionUpgrade": Schema{
			Type: ValueBool,
		},

		"CacheNodeType": Schema{
			Type:     cacheNodeType,
			Required: constraints.Always,
		},

		"CacheParameterGroupName": Schema{
			Type: ValueString,
		},

		"CacheSecurityGroupNames": Schema{
			Type:      Multiple(cacheSecurityGroupName),
			Conflicts: constraints.PropertyExists("SecurityGroupIds"),
		},

		"CacheSubnetGroupName": Schema{
			Type: cacheSubnetGroupName,
		},

		"Engine": Schema{
			Type:         engine,
			Required:     constraints.Always,
			ValidateFunc: SingleValueValidate("redis"),
		},

		"EngineVersion": Schema{
			Type: ValueString,
		},

		"NotificationTopicArn": Schema{
			Type: ARN,
		},

		"NumCacheClusters": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
			ValidateFunc: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
				if val, ok := ctx.CurrentResource().PropertyValueOrDefault("AutomaticFailoverEnabled"); ok && val.(bool) == true {
					if value.(float64) <= 1 {
						return reporting.ValidateOK, reporting.Reports{reporting.NewFailure(ctx, "Must be greater than 1 if automatic failover is enabled")}
					}
				}

				return reporting.ValidateOK, nil
			},
		},

		"Port": Schema{
			Type: ValueNumber,
		},

		"PreferredCacheClusterAZs": Schema{
			Type: Multiple(AvailabilityZone),
		},

		"PreferredMaintenanceWindow": Schema{
			Type: ValueString,
		},

		"ReplicationGroupDescription": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"SecurityGroupIds": Schema{
			Type:      Multiple(SecurityGroupID),
			Conflicts: constraints.PropertyExists("CacheSecurityGroupNames"),
		},

		"SnapshotArns": Schema{
			Type: Multiple(ARN),
		},

		"SnapshotRetentionLimit": Schema{
			Type: ValueNumber,
		},

		"SnapshotWindow": Schema{
			Type: ValueString,
		},
	},
}

var SecurityGroup = Resource{
	AwsType: "AWS::ElastiCache::SecurityGroup",

	ReturnValue: Schema{
		Type: cacheSecurityGroupName,
	},

	Properties: Properties{
		"Description": Schema{
			Type: ValueString,
		},
	},
}

var SecurityGroupIngress = Resource{
	AwsType: "AWS::ElastiCache::SecurityGroupIngress",

	Properties: Properties{
		"CacheSecurityGroupName": Schema{
			Type:     cacheSecurityGroupName,
			Required: constraints.Always,
		},

		"EC2SecurityGroupName": Schema{
			Type:     SecurityGroupName,
			Required: constraints.Always,
		},

		"EC2SecurityGroupOwnerId": Schema{
			Type: ValueString,
		},
	},
}

var SubnetGroup = Resource{
	AwsType: "AWS::ElastiCache::SubnetGroup",

	ReturnValue: Schema{
		Type: cacheSubnetGroupName,
	},

	Properties: Properties{
		"Description": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"SubnetIds": Schema{
			Type:     Multiple(SubnetID),
			Required: constraints.Always,
		},
	},
}