private IEnumerable GenerateBuildAndPushType()

in tool/TeamCity.Docker/TeamCityKotlinSettingsGenerator.cs [636:773]
108 lines of code
22 McCabe index (conditional complexity)

        private IEnumerable<string> GenerateBuildAndPushType(
            string buildTypeId,
            string name,
            IReadOnlyCollection<INode<IArtifact>> path,
            int weight,
            bool onPause)
        {
            var images = path.Select(i => i.Value).OfType<Image>().Where(i => onPause || i.File.Repositories.Any()).ToList();
            var references = path.Select(i => i.Value).OfType<Reference>().ToList();

            var groups =
                from image in images
                group image by image.File.ImageId
                into groupsByImageId
                from groupByImageId in
                    from image in groupsByImageId
                    group image by image.File
                group groupByImageId by groupsByImageId.Key;

            var description = new StringBuilder();
            foreach (var grp in groups)
            {
                if (description.Length > 0)
                {
                    description.Append(" ");
                }

                description.Append(grp.Key);
                foreach (var dockerfile in grp)
                {
                    var tags = string.Join(",", dockerfile.Key.Tags);
                    if (!string.IsNullOrWhiteSpace(tags))
                    {
                        description.Append(':');
                        description.Append(tags);
                    }
                }
            }

            var pauseStr = onPause ? "ON PAUSE " : "";
            yield return $"object {buildTypeId} : BuildType({{";
            yield return $"\t name = \"{pauseStr}Build and push {name}\"";
            yield return $"\t {_buildNumberPattern}";
            yield return $"\t description  = \"{description}\"";

            if (!onPause)
            {
                yield return "\t vcs {";
                yield return "\t\t root(TeamCityDockerImagesRepo)";
                yield return "\t }";


                yield return "\n \t steps {";

                // "docker pull" command types @ steps { ... } block
                foreach (var command in references.SelectMany(refer => CreatePullCommand(refer.RepoTag, refer.RepoTag)))
                {
                    yield return $"\t\t{command}";
                }

                // "docker build" command types @ steps { ... } block
                foreach (var command in images.SelectMany(image => CreatePrepareContextCommand(image).Concat(CreateBuildCommand(image))))
                {
                    yield return $"\t\t{command}";
                }

                // "docker image tag" command types @ steps { ... } block
                foreach (var image in images)
                {
                    if (image.File.Tags.Any())
                    {
                        var tag = image.File.Tags.First();

                        // "tag" command
                        foreach (var tagCommand in CreateTagCommand($"{image.File.ImageId}:{tag}", $"{BuildRepositoryName}{image.File.ImageId}{BuildImagePostfix}:{tag}", $"{image.File.ImageId}:{tag}"))
                        {
                            yield return $"\t\t{tagCommand}";
                        }
                    }
                }

                // "docker push" command types @ steps { ... } block
                foreach (var image in images)
                {
                    var tag = image.File.Tags.First();
                    foreach (var pushCommand in CreatePushCommand($"{BuildRepositoryName}{image.File.ImageId}{BuildImagePostfix}", $"{image.File.ImageId}:{tag}", tag))
                    {
                        yield return $"\t\t{pushCommand}";
                    }
                }

                // end of steps {...} block
                yield return "\t}";

                yield return "\tfeatures {";

                if (weight > 0)
                {
                    foreach (var feature in CreateFreeDiskSpaceFeature(weight))
                    {
                        yield return $"\t\t{feature}";
                    }
                }

                foreach (var feature in CreateDockerFeature())
                {
                    yield return $"\t\t{feature}";
                }

                // ReSharper disable once StringLiteralTypo
                foreach (var feature in CreateSwabraFeature())
                {
                    yield return $"\t\t{feature}";
                }

                // end of features { ... } block
                yield return "\t}";

                foreach (var dependencies in CreateArtifactsDependencies())
                {
                    yield return $"\t{dependencies}";
                }

                foreach (var param in CreateSpaceParams(weight))
                {
                    yield return $"\t{param}";
                }
                
                var requirements = images.SelectMany(i => i.File.Requirements).Distinct().ToList();
                foreach (var lines in CreateDockerRequirements(requirements))
                {
                    yield return $"\t{lines}";
                }
            }

            yield return "})";
            yield return string.Empty;
        }