// Helper function to create an EFS Filesystem.
func CreateFilesystem(e *efs.EFS, n string) (*efs.FileSystemDescription, error) {
	createParams := &efs.CreateFileSystemInput{
		CreationToken: aws.String(n),
	}
	createResp, err := e.CreateFileSystem(createParams)
	if err != nil {
		return nil, err
	}

	// Wait for the filesystem to become available.
	for {
		fs, err := DescribeFilesystem(e, n)
		if err != nil {
			return nil, err
		}
		if len(fs.FileSystems) > 0 {
			if *fs.FileSystems[0].LifeCycleState == efsAvail {
				break
			}
		}
		time.Sleep(10 * time.Second)
	}

	return createResp, nil
}

func (d *driver) getFileSystemLifeCycleState(
	svc *awsefs.EFS,
	fileSystemID string) (string, error) {

	resp, err := svc.DescribeFileSystems(
		&awsefs.DescribeFileSystemsInput{
			FileSystemId: aws.String(fileSystemID)})
	if err != nil {
		return "", err
	}

	fileSystem := resp.FileSystems[0]
	return *fileSystem.LifeCycleState, nil
}

// Retrieve all filesystems with tags from AWS API. This is very expensive
// operation as it issues AWS SDK call per filesystem to retrieve tags.
func (d *driver) getAllFileSystems(
	svc *awsefs.EFS) (filesystems []*awsefs.FileSystemDescription, err error) {

	resp, err := svc.DescribeFileSystems(&awsefs.DescribeFileSystemsInput{})
	if err != nil {
		return nil, err
	}
	filesystems = append(filesystems, resp.FileSystems...)

	for resp.NextMarker != nil {
		resp, err = svc.DescribeFileSystems(&awsefs.DescribeFileSystemsInput{
			Marker: resp.NextMarker,
		})
		if err != nil {
			return nil, err
		}
		filesystems = append(filesystems, resp.FileSystems...)
	}

	return filesystems, nil
}

// Helper function to create an EFS Mount target.
func CreateMountTarget(e *efs.EFS, i string, s string) (*efs.MountTargetDescription, error) {
	var security []*string

	// Determine if we need to assign a security group to this mount point, otherwise defer
	// to the default group.
	if *cliSecurity != "" {
		security = []*string{
			cliSecurity,
		}
	}

	params := &efs.CreateMountTargetInput{
		FileSystemId:   aws.String(i),
		SubnetId:       aws.String(s),
		SecurityGroups: security,
	}
	resp, err := e.CreateMountTarget(params)
	if err != nil {
		return nil, err
	}

	// Wait for the mount point to become available.
	for {
		mnt, err := DescribeMountTarget(e, i)
		if err != nil {
			return nil, err
		}
		if len(mnt.MountTargets) > 0 {
			if *mnt.MountTargets[0].LifeCycleState == efsAvail {
				break
			}
		}
		time.Sleep(10 * time.Second)
	}

	return resp, nil
}

// setTags is a helper to set the tags for a resource. It expects the
// tags field to be named "tags"
func setTagsEFS(conn *efs.EFS, d *schema.ResourceData) error {
	if d.HasChange("tags") {
		oraw, nraw := d.GetChange("tags")
		o := oraw.(map[string]interface{})
		n := nraw.(map[string]interface{})
		create, remove := diffTagsEFS(tagsFromMapEFS(o), tagsFromMapEFS(n))

		// Set tags
		if len(remove) > 0 {
			log.Printf("[DEBUG] Removing tags: %#v", remove)
			k := make([]*string, 0, len(remove))
			for _, t := range remove {
				k = append(k, t.Key)
			}
			_, err := conn.DeleteTags(&efs.DeleteTagsInput{
				FileSystemId: aws.String(d.Id()),
				TagKeys:      k,
			})
			if err != nil {
				return err
			}
		}
		if len(create) > 0 {
			log.Printf("[DEBUG] Creating tags: %#v", create)
			_, err := conn.CreateTags(&efs.CreateTagsInput{
				FileSystemId: aws.String(d.Id()),
				Tags:         create,
			})
			if err != nil {
				return err
			}
		}
	}

	return nil
}

// Helper function to describe EFS Filesystems.
func DescribeFilesystem(e *efs.EFS, n string) (*efs.DescribeFileSystemsOutput, error) {
	params := &efs.DescribeFileSystemsInput{
		CreationToken: aws.String(n),
	}
	return e.DescribeFileSystems(params)
}

// Helper function to describe an EFS Mount target.
func DescribeMountTarget(e *efs.EFS, i string) (*efs.DescribeMountTargetsOutput, error) {
	params := &efs.DescribeMountTargetsInput{
		FileSystemId: aws.String(i),
	}
	return e.DescribeMountTargets(params)
}