package main

import (
	"encoding/json"
	"fmt"
	"maps"
	"net/url"
	"os"
	"strings"

	"cloud.o-forge.io/core/oc-catalog/models"

	"github.com/beego/beego/v2/core/logs"
	"github.com/sbabiv/xml2map"
	"github.com/tidwall/gjson"
)

type Link struct {
	Src string
	Dst string
}

type Graph struct {
	Datas       []models.DataModel
	Computings  []models.ComputingModel
	Datacenters []models.DatacenterModel
	Storages    []models.StorageModel
	Links		map[string]models.Link 
	ws          HttpQuery
}

// Create a dictionnaries with each each existing workflow from a workspace, associated to the JSON representation of its content

func (g *Graph) GetGraphList(apiurl string) (map[string]string, error) {
	g.ws.Init(apiurl)
	body, err := g.ws.Get("v1/workspace/list")
	if err != nil {
		return nil, err
	}
	workspaces := make(map[string]string)
	result := gjson.Get(string(body), "Workflows")
	result.ForEach(func(key, value gjson.Result) bool {
		workspaces[key.Str] = value.String()
		return true // keep iterating
	})
	return workspaces, nil
}

// Create the objects from the mxgraphxml stored in the workflow given as a parameter

func (g *Graph) LoadFrom(workspace string) error {
	// Extract the xmlgraph from the given workspace
	xml := gjson.Get(workspace, "MxgraphXML").String()
	decodedValue, err := url.QueryUnescape(xml)
	if err != nil {
		return err
	}

	os.WriteFile("graph.xml", []byte(decodedValue), 0660)
	decoder := xml2map.NewDecoder(strings.NewReader(decodedValue))
	result, err := decoder.Decode()
	if err != nil {
		return err
	}

	// Retrieve the content of mxcell and object elements
	cells := result["mxGraphModel"].(map[string]interface{})["root"].(map[string]interface{})["mxCell"].([]map[string]interface{})
	obj := result["mxGraphModel"].(map[string]interface{})["root"].(map[string]interface{})["object"]
	
	// Append the content of obj to cells depending on if it's a single key/value pair or a list of it
	switch v := obj.(type) {
	
	case map[string]interface{}:
		cells = append(cells, obj.(map[string]interface{}))
		_ = v
		// fmt.Printf("One: %v", v)
	case []map[string]interface{}:
		cells = append(cells, obj.([]map[string]interface{})...)
		// fmt.Printf("Many: %v", v)
	}
	
	// dictionnary := make(map[string]string)
	var idlinks []Link
	
	g.GetWorkflowComponents(workspace)
	g.GetLinks(workspace)

	for _, element := range cells {
		// id := element["@id"].(string)
		// // Case MXCell
		// if _, ok := element["@style"]; ok {
		// 	if _, ok2 := element["@rID"]; ok2 {
		// 		// Resolve elements
		// 		// fmt.Print(id + ": ")
		// 		// fmt.Println(element["@rID"], element["@rType"])
		// 		// fmt.Println(element)
		// 		dictionnary[id] = element["@rID"].(string)
		// 		g.addElementByType(element)
		// 	}
		// } else {
		// 	// Case object : contains user's input through the GUI
		// 	if _, ok := element["mxCell"]; ok {
		// 		// Attribute values

		// 		// Extracts the cell ids
		// 		element = element["mxCell"].(map[string]interface{})
		// 		if _, ok := element["@style"]; ok {
		// 			if _, ok2 := element["@rID"]; ok2 {
		// 				// Resolve elements
		// 				// fmt.Print(id + ": ")
		// 				// fmt.Println(element["@rID"], element["@rType"])
		// 				// fmt.Println(element)
		// 				dictionnary[id] = element["@rID"].(string)
		// 				g.addElementByType(element)
		// 			}
		// 		}
		// 	}

		// }
		// register links
		if src, ok := element["@source"]; ok {
			//src = element["@source"].(string)
			idlinks = append(idlinks, Link{Src: src.(string), Dst: element["@target"].(string)})
			// fmt.Println("Link: " + src.(string) + " " + element["@target"].(string))
		}

	}

	// translate links
	// for _, link := range idlinks {
	// 	g.Links = append(g.Links, Link{Src: dictionnary[link.Src], Dst: dictionnary[link.Dst]})
	// 	fmt.Println("Link: " + link.Src + " " + link.Dst + " : " + dictionnary[link.Src] + " " + dictionnary[link.Dst])
	// }
	return nil
}


// TODO : extract all the JSON/data processing to a new object that takes
// the current graph as an attribute and deals with adding new objects
// to it, depending on their type

// Create the objects that correspond to each component
// in a workflow, combining the user input and the base components attributes

func (g *Graph) GetWorkflowComponents(workflow string){
	types := []string{"computing","datacenter","data","storage"}	// create a constant for more maintainability OR even better get the list of all component's type for this WF	
	for _, component_type := range types {
		// Retrieve the dict of component for a specific type in the workflow
		result := gjson.Get(workflow, component_type)
		
		if (result.Type != gjson.Null) {
			result.ForEach(func(id, value gjson.Result) bool{
				comp_id := value.Get("referenceID").Str

				if (comp_id != "") {
					switch component_type {
						case "computing":
							g.AddComputingModel(comp_id, value, id.Str)
						case "data":
							g.AddDataModel(comp_id, value, id.Str)
						case "datacenter":
							g.AddDatacenterModel(comp_id, value, id.Str)
						case "storage":
							g.AddStorageModel(comp_id, value, id.Str)			
						default :
							logs.Critical("Component type doesn't match a know type : " + component_type)
					}
				}
				return true
			})
		}	
	}
	
}

func (g *Graph) GetLinks(workflow string){
	g.Links = make(map[string]models.Link)
	result := gjson.Get(workflow, "link")
	
	if (result.Type != gjson.Null) {
		result.ForEach(func(id, value gjson.Result) bool{
			var l models.Link
			
			json.Unmarshal([]byte(value.Raw),&l)			
			g.Links[id.Str] = l
			return true
		})
	}
} 

func (g *Graph) AddDataModel(id string, user_input gjson.Result, wf_id string) error {
	var d models.DataModel
	resp, err := g.ws.Get("v1/data/" + id)
	if err != nil {
		return err
	}
	json.Unmarshal(resp, &d)
	json.Unmarshal([]byte(user_input.Raw),&d.DataNEWModel)
	d.ID = wf_id
	g.Datas = append(g.Datas, d)
	return nil
}

func (g *Graph) AddDatacenterModel(id string, user_input gjson.Result, wf_id string) error {
	var d models.DatacenterModel
	resp, err := g.ws.Get("v1/datacenter/" + id)
	if err != nil {
		return err
	}
	json.Unmarshal(resp, &d)
	json.Unmarshal([]byte(user_input.Raw),&d.DatacenterNEWModel)
	d.ID = wf_id
	g.Datacenters = append(g.Datacenters, d)
	return nil
}

func (g *Graph) AddComputingModel(id string, user_input gjson.Result, wf_id string) error {
	var c models.ComputingModel
	resp, err := g.ws.Get("v1/computing/" + id)
	if err != nil {
		return err
	}
	json.Unmarshal(resp, &c)
	json.Unmarshal([]byte(user_input.Raw),&c.ComputingNEWModel)
	c.ID = wf_id
	g.Computings = append(g.Computings, c)
	return nil
}

func (g *Graph) AddStorageModel(id string, user_input gjson.Result, wf_id string) error {
	var s models.StorageModel
	resp, err := g.ws.Get("v1/storage/" + id)
	if err != nil {
		return err
	}
	json.Unmarshal(resp, &s)
	json.Unmarshal([]byte(user_input.Raw),&s.StorageNEWModel)
	s.ID = wf_id
	g.Storages = append(g.Storages, s)
	return nil
}

func (g *Graph) ExportToArgo(id string) error {
	end_links := make(map[string]models.Link)
	
	for i, link := range g.Links {
		if (!link.DCLink && !g.isSource(link.Destination,i)){
			end_links[i] = link
		}
	}
	
	// index_list := make([]int, len(g.Links))
	// list_branches := make([][]string,0)
	list_branches := g.getListBranches(end_links, nil,nil)
		
	for _, branch := range list_branches{
		str := ""
		for _, link := range branch{
			str =  str + " --> " + g.getComponentName(g.Links[link].Source) + " linked with " + g.getComponentName(g.Links[link].Destination) 
		}

		fmt.Println(str)
	}

	fmt.Println("Identified branches : ", list_branches)
	argo_builder := ArgoBuilder{graph : *g, branches:  list_branches}
	argo_builder.CreateDAG()

	return nil
}

// Return a list containing the IDs of each link that make up a branch in the graph
func (g *Graph) getListBranches(end_links map[string]models.Link, unvisited_links_list map[string]models.Link, current_branch []string) (list_branches [][]string) {
	if current_branch == nil {
		current_branch = make([]string, 0)
	}

	if unvisited_links_list == nil {
		unvisited_links_list = make(map[string]models.Link,len(g.Links))
		maps.Copy(unvisited_links_list,g.Links)
		fmt.Println(unvisited_links_list)
	}
	
	for link_id, _ := range end_links {
		j := link_id
		new_branches := make([][]string,0)

		previous_index := g.getPreviousLink(j, unvisited_links_list)
		if len(previous_index) == 0 {
			list_branches = append(list_branches, []string{link_id})
		}

		for _, id_link := range previous_index {
			current_branch = append([]string{link_id},current_branch...)
			delete(unvisited_links_list, link_id)
			// create a new branch for each previous link, appending the current path to this node to the created branch
			new_end_link := make(map[string]models.Link,0)
			new_end_link[id_link] = g.Links[id_link]
			new_branches = g.getListBranches(new_end_link,unvisited_links_list,current_branch)		
				
			for _, new_branch := range new_branches{
				current_branch = append(new_branch,link_id)
				list_branches = append(list_branches, current_branch)
			}
		}
	}

	return 
}

func (g *Graph) ExportToHelm(id string) error {

	return nil
}

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

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

// Returns an index number if their is a link in g.Links
// with the same Destination id that the Source id in g.Links[linkIndex]
// or nil if not

func (g *Graph) getPreviousLink(link_id string,map_link map[string]models.Link) (previous_id []string) {
	for k, link := range map_link{
		if(k != link_id && link.Destination == g.Links[link_id].Source){
			previous_id = append(previous_id, k)
		}
	}
	
	return 
}

func (g *Graph) getComponentName(id string) string {

	for _, comp := range g.Computings{
		if comp.ID == id {
			return comp.Name
		}
	}
	for _, storage := range g.Storages{
		if storage.ID == id {
			return storage.Name
		}
	}
	for _, data := range g.Datas{
		if data.ID == id {
			return data.Name
		}
	}

	return ""
}

func getMapKeys(m map[int]interface{}) []int {
    var list_keys []int

	for key := range m {
        fmt.Println("Key:", key)
    }

	return list_keys
}

func (g *Graph) getComponentType(component_id string) string {
	for _, comp := range g.Computings {
		if comp.ID == component_id{
			return "computing"
		}
	}

	for _, data := range g.Datas {
		if data.ID == component_id{
			return "data"
		}
	}
	
	for _, storage := range g.Storages {
		if storage.ID == component_id{
			return "storage"
		}
	}

	return ""
}

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

func (g *Graph) getComponentByType(compType string, link models.Link) (ids []string){
	if(g.getComponentType(link.Source) == compType){
		ids = append(ids, link.Source)
	}
	if(g.getComponentType(link.Destination) == compType){
		ids = append(ids, link.Destination)
	}

	return
}