private static JsonSchema Collapse()

in src/Json.Schema/JsonSchema.cs [420:570]
131 lines of code
24 McCabe index (conditional complexity)

        private static JsonSchema Collapse(JsonSchema schema, JsonSchema rootSchema)
        {
            JsonSchema collapsedSchema = new JsonSchema(schema);

            if (schema.Items != null)
            {
                collapsedSchema.Items = new Items(
                    new List<JsonSchema>(
                        schema.Items.Schemas.Select(
                            itemSchema => Collapse(itemSchema, rootSchema))));
                collapsedSchema.Items.SingleSchema = schema.Items.SingleSchema;
            }

            if (schema.Properties != null)
            {
                collapsedSchema.Properties = new Dictionary<string, JsonSchema>();
                foreach (string key in schema.Properties.Keys)
                {
                    collapsedSchema.Properties.Add(
                        key, Collapse(schema.Properties[key], rootSchema));
                }
            }

            if (schema.Definitions != null)
            {
                collapsedSchema.Definitions = new Dictionary<string, JsonSchema>();
                foreach (string key in schema.Definitions.Keys)
                {
                    collapsedSchema.Definitions.Add(
                        key, Collapse(schema.Definitions[key], rootSchema));
                }
            }

            if (schema.AdditionalItems?.Schema != null)
            {
                collapsedSchema.AdditionalItems = new AdditionalItems(
                    Collapse(schema.AdditionalItems?.Schema, rootSchema));
            }

            if (schema.AdditionalProperties?.Schema != null)
            {
                collapsedSchema.AdditionalProperties = new AdditionalProperties(
                    Collapse(schema.AdditionalProperties?.Schema, rootSchema));
            }

            if (schema.Dependencies != null)
            {
                collapsedSchema.Dependencies = new Dictionary<string, Dependency>();
                foreach (string key in schema.Dependencies.Keys)
                {
                    Dependency collapsedDependency;
                    if (schema.Dependencies[key].SchemaDependency != null)
                    {
                        collapsedDependency = new Dependency(
                            Collapse(
                                schema.Dependencies[key].SchemaDependency,
                                rootSchema));
                    }
                    else
                    {
                        collapsedDependency = new Dependency(
                            new List<string>(
                                schema.Dependencies[key].PropertyDependencies));
                    }

                    collapsedSchema.Dependencies.Add(key, collapsedDependency);
                }
            }

            if (schema.PatternProperties != null)
            {
                collapsedSchema.PatternProperties = new Dictionary<string, JsonSchema>();
                foreach (string key in schema.PatternProperties.Keys)
                {
                    collapsedSchema.PatternProperties.Add(
                        key, Collapse(schema.PatternProperties[key], rootSchema));
                }
            }

            if (schema.AllOf != null)
            {
                collapsedSchema.AllOf = schema.AllOf.Select(s => Collapse(s, rootSchema)).ToList();
            }

            if (schema.AnyOf != null)
            {
                collapsedSchema.AnyOf = schema.AnyOf.Select(s => Collapse(s, rootSchema)).ToList();
            }

            if (schema.OneOf != null)
            {
                collapsedSchema.OneOf = schema.OneOf.Select(s => Collapse(s, rootSchema)).ToList();
            }

            if (schema.Not != null)
            {
                collapsedSchema.Not = Collapse(schema.Not, rootSchema);
            }

            if (schema.Reference != null)
            {
                if (!schema.Reference.IsFragment)
                {
                    throw Error.CreateException(
                        Resources.ErrorOnlyDefinitionFragmentsSupported,
                        schema.Reference);
                }

                string definitionName = schema.Reference.GetDefinitionName();

                if (rootSchema.Definitions == null || !rootSchema.Definitions.TryGetValue(definitionName, out JsonSchema referencedSchema))
                {
                    throw Error.CreateException(
                        Resources.ErrorDefinitionDoesNotExist,
                        definitionName);
                }

                if (referencedSchema.Type != null)
                {
                    collapsedSchema.Type = new List<SchemaType>(referencedSchema.Type);
                }

                if (referencedSchema.Enum != null)
                {
                    collapsedSchema.Enum = new List<object>(referencedSchema.Enum);
                }

                if (referencedSchema.Items != null)
                {
                    collapsedSchema.Items = new Items(
                        new List<JsonSchema>(
                            referencedSchema.Items.Schemas.Select(
                                itemSchema => Collapse(itemSchema, rootSchema))));
                    collapsedSchema.Items.SingleSchema = referencedSchema.Items.SingleSchema;
                }

                collapsedSchema.Default = referencedSchema.Default;
                collapsedSchema.Pattern = referencedSchema.Pattern;
                collapsedSchema.MaxLength = referencedSchema.MaxLength;
                collapsedSchema.MinLength = referencedSchema.MinLength;
                collapsedSchema.MultipleOf = referencedSchema.MultipleOf;
                collapsedSchema.Maximum = referencedSchema.Maximum;
                collapsedSchema.ExclusiveMaximum = referencedSchema.ExclusiveMaximum;
                collapsedSchema.MinItems = referencedSchema.MinItems;
                collapsedSchema.MaxItems = referencedSchema.MaxItems;
                collapsedSchema.UniqueItems = referencedSchema.UniqueItems;
                collapsedSchema.Format = referencedSchema.Format;
            }

            return collapsedSchema;
        }