package workflow_builder

import (
	"errors"
	"fmt"

	"oc-monitor/logger"
	models "oc-monitor/models"

	oclib "cloud.o-forge.io/core/oc-lib"
	"cloud.o-forge.io/core/oc-lib/models/resources/workflow/graph"
	workflow "cloud.o-forge.io/core/oc-lib/models/workflow"
)



type WorflowDB struct {
	workflow_name	string							// used to test if the graph has been instatiated, private so can only be set by a graph's method
	graph 			*graph.Graph
	ws          	models.HttpQuery
}

// Create the obj!ects from the mxgraphxml stored in the workflow given as a parameter
func (w *WorflowDB) LoadFrom(workflow_id string) error {
	
	new_wf, err := w.getWorkflow(workflow_id)
	if err != nil {
		return err
	}

	w.graph = new_wf.Graph 

	w.workflow_name = new_wf.Name
	
	return nil
}

// Use oclib to retrieve the graph contained in the workflow referenced
func (w *WorflowDB) getWorkflow( workflow_id string) (workflow *workflow.Workflow, err error) {

	lib_data := oclib.LoadOne(oclib.LibDataEnum(oclib.WORKFLOW),workflow_id)
	if lib_data.Code != 200 {
		logger.Logger.Error().Msg("Error loading the graph")
		return workflow, errors.New(lib_data.Err)
	}

	new_wf := lib_data.ToWorkflow()
	if new_wf == nil {
		logger.Logger.Error().Msg("WorflowDB object is empty for " + workflow_id )
		return workflow, errors.New("WorflowDB can't be empty")
	}

	return new_wf, nil
}


func (w *WorflowDB) ExportToArgo() (string, error) {
	if len(w.workflow_name) == 0 || &w.graph == nil {
		return "",fmt.Errorf("can't export a graph that has not been loaded yet")
	}
	
	
	argo_builder := ArgoBuilder{graph : *w.graph}
	filename, err := argo_builder.CreateDAG()
	if err != nil {
		logger.Logger.Error().Msg("Could not create the argo file for " + w.workflow_name)
		return "", err
	}
 	return filename, nil
}

func (w *WorflowDB) ExportToHelm(id string) error {

	return nil
}

// Return if it exists a link where Destination is the same as comp_id
func (w *WorflowDB) isDestination(comp_id string,link_id int) bool {
	
	for i, link := range w.graph.Links{
		if(i !=link_id && link.Destination.ID == comp_id){
			return true
		}
	}
	
	return false
	
}

// Return if it exists a link where Source is the same as comp_id
func (w *WorflowDB) isSource(comp_id string, link_id int) bool {
	
	for i, link := range  w.graph.Links{
		if(i !=link_id && link.Source.ID == comp_id && !w.isDCLink(i)){
			return true
		}
	}
	
	return false
	
}



// returns either computing, data or storage
func GetComponentType(component_id string) string {
	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.PROCESSING_RESOURCE),component_id); libdata.Code == 200{
		return "computing"
	}
	
	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.DATA_RESOURCE),component_id); libdata.Code == 200{
		return "data"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.STORAGE_RESOURCE),component_id); libdata.Code == 200{
		return "storage"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.DATACENTER_RESOURCE),component_id); libdata.Code == 200{
		return "datacenter"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.WORKFLOW_RESOURCE),component_id); libdata.Code == 200{
		return "workflow"
	}

	return ""
}

// Returns a slice of id, in case the link is made of twice the same type of component

func (w *WorflowDB) getComponentByType(compType string, link graph.GraphLink) (ids []string){
	if(GetComponentType(link.Source.ID) == compType){
		ids = append(ids, link.Source.ID)
	}
	if(GetComponentType(link.Destination.ID) == compType){
		ids = append(ids, link.Destination.ID)
	}

	return
}

func (w *WorflowDB) isDCLink(link_id int) bool {
	link :=  w.graph.Links[link_id]

	dest := w.graph.Items[link.Destination.ID]
	dest_id := dest.GetAbstractRessource().GetID()
	
	source := w.graph.Items[link.Source.ID]
	source_id := source.GetAbstractRessource().GetID()
	
	return IsDatacenter(dest_id) || IsDatacenter(source_id)
}

func IsDatacenter(id string) bool {
	resource := oclib.LoadOne(oclib.LibDataEnum(oclib.DATACENTER_RESOURCE),id)
	
	return resource.Code == 200 
}