/*
 *  Copyright © 2019 IBM.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils

import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.asListOfString
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition

object ResourceDefinitionUtils {

    fun definitionDependencies(definition: ResourceDefinition, sources: List<String>): Set<String> {
        val dependencies: MutableSet<String> = mutableSetOf()
        definition.sources.forEach { (sourceName, source) ->
            if (sources.contains(sourceName)) {
                val keyDependenciesExists = source.properties?.containsKey("key-dependencies") ?: false
                if (keyDependenciesExists) {
                    dependencies.addAll(source.properties!!["key-dependencies"]!!.asListOfString())
                }
            }
        }
        return dependencies
    }

    /** Create a processing resource assignments for the resource definition  */
    fun createResourceAssignments(resourceDefinitions: MutableMap<String, ResourceDefinition>,
                                  resolveDefinition: String, sources: List<String>)
            : MutableList<ResourceAssignment> {
        /** Check if resolve definition is defined in the resource definition Map */
        val resourceDefinition = resourceDefinitions[resolveDefinition]
                ?: throw BluePrintProcessorException("failed to get resolve definition($resolveDefinition)")

        val resourceAssignments: MutableList<ResourceAssignment> = arrayListOf()
        /** Get the dependency property fields for the the resource definition to resolve */
        val definitionDependencies = definitionDependencies(resourceDefinition, sources)
        definitionDependencies.forEach { definitionDependencyName ->
            val definitionDependency = resourceDefinitions[definitionDependencyName]
                    ?: throw BluePrintProcessorException("failed to get dependency definition($definitionDependencyName)")

            val resourceAssignment = ResourceAssignment().apply {
                name = definitionDependency.name
                dictionaryName = definitionDependency.name
                /** The assumption is al resource are already resolved and shall get as input source */
                dictionarySource = "input"
                property = definitionDependency.property
            }
            resourceAssignments.add(resourceAssignment)
        }

        resourceDefinition.sources.forEach { (sourceName, source) ->
            if (sources.contains(sourceName)) {
                val resourceAssignment = ResourceAssignment().apply {
                    name = "$sourceName:${resourceDefinition.name}"
                    dictionaryName = resourceDefinition.name
                    dictionarySource = sourceName
                    dictionarySourceDefinition = source
                    // Clone the PropertyDefinition, otherwise property value will be overridden
                    property = JacksonUtils
                            .readValue(resourceDefinition.property.asJsonString(), PropertyDefinition::class.java)
                    val keyDependenciesExists = source.properties?.containsKey("key-dependencies") ?: false
                    if (keyDependenciesExists) {
                        dependencies = source.properties!!["key-dependencies"]!!.asListOfString().toMutableList()
                    }
                }
                resourceAssignments.add(resourceAssignment)
            }
        }
        // Populate Resource Definition's dependencies as Input Resource Assignment
        return resourceAssignments
    }
}