package slurmer

/*
#cgo LDFLAGS: -lslurm
#include<stdlib.h>
#include<slurm/slurm.h>



 struct partition_info_msg *get_partition_info(){
   	struct partition_info_msg* partition_buffer;
        if( slurm_load_partitions ((time_t) NULL,
		&partition_buffer, SHOW_ALL))
		return NULL;
	return partition_buffer;
 }
 struct partition_info* partition_from_list(struct partition_info_msg *list, int i){
	 return &list->partition_array[i];
}
 void free_partition_buffer(void* buffer){

	slurm_free_partition_info_msg ((struct partition_info_msg*)buffer);
  }
*/
import "C"
import (
	pbslurm "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
	"context"
	"strings"
)

func Partition_info_convert_c_to_go(c_struct *C.struct_partition_info) pbslurm.PartitionInfo {
	var go_struct pbslurm.PartitionInfo

	go_struct.AllowAllocNodes = C.GoString(c_struct.allow_alloc_nodes)
	go_struct.AllowGroups = C.GoString(c_struct.allow_groups)
	go_struct.Alternate = C.GoString(c_struct.alternate)
	go_struct.CrType = uint32(c_struct.cr_type)
	go_struct.DefMemPerCpu = uint64(c_struct.def_mem_per_cpu)
	go_struct.DefaultTime = uint32(c_struct.default_time)
	go_struct.Flags = uint32(c_struct.flags)
	go_struct.GraceTime = uint32(c_struct.grace_time)
	go_struct.MaxCpusPerNode = uint32(c_struct.max_cpus_per_node)
	go_struct.MaxMemPerCpu = uint64(c_struct.max_mem_per_cpu)
	go_struct.MaxNodes = uint32(c_struct.max_nodes)
	go_struct.MaxShare = uint32(c_struct.max_share)
	go_struct.MaxTime = uint32(c_struct.max_time)
	go_struct.MinNodes = uint32(c_struct.min_nodes)
	go_struct.Name = C.GoString(c_struct.name)
	//go_struct.Node_inx = int32(C.int32_ptr(c_struct.node_inx))
	/*t := C.find_node_inx(c_struct.node_inx)
	fmt.Printf("%d", t)
	go_struct.Node_inx = make([]int32, t, t)
	for i := int32(0); i < int32(t); i++ {
		go_struct.Node_inx[i] = int32(C.int32_ptr(c_struct.node_inx, C.int(i)))

	}*/
	go_struct.Nodes = C.GoString(c_struct.nodes)
	go_struct.PreemptMode = uint32(c_struct.preempt_mode)
	go_struct.StateUp = uint32(c_struct.state_up)
	go_struct.TotalCpus = uint32(c_struct.total_cpus)
	go_struct.TotalNodes = uint32(c_struct.total_nodes)
	return go_struct
}

type PartitionInfoMsg struct {
	LastUpdate        int64
	RecordCount       uint32
	PartitionInfoList []pbslurm.PartitionInfo
}

func Get_partitions() PartitionInfoMsg {
	var go_partition_buffer PartitionInfoMsg
	c_partition_buffer := C.get_partition_info()
	if c_partition_buffer == nil {
		go_partition_buffer.LastUpdate = int64(0)
		go_partition_buffer.RecordCount = uint32(0)
		return go_partition_buffer
	}
	go_partition_buffer.LastUpdate = int64(c_partition_buffer.last_update)
	go_partition_buffer.RecordCount = uint32(c_partition_buffer.record_count)
	go_partition_buffer.PartitionInfoList = make([]pbslurm.PartitionInfo, c_partition_buffer.record_count, c_partition_buffer.record_count)
	for i := uint32(0); i < go_partition_buffer.RecordCount; i++ {
		partition := C.partition_from_list(c_partition_buffer, C.int(i))
		go_partition := Partition_info_convert_c_to_go(partition)
		go_partition_buffer.PartitionInfoList[i] = go_partition
	}
	C.slurm_free_partition_info_msg(c_partition_buffer)

	return go_partition_buffer
}

func (slurmStruct SlurmStruct) ListPartitions(ctx context.Context, req *pbslurm.ListPartitionsReq) (*pbslurm.ListPartitionsResp, error) {
	partitionList := Get_partitions()
	var resp = pbslurm.ListPartitionsResp{}
	for _, partition := range partitionList.PartitionInfoList {
		partitionInfoResult := partition
		resp.PartitionList = append(resp.PartitionList, &partitionInfoResult)
	}
	return &resp, nil
}

func GetPartitionsInfo() PartitionInfoMsg {
	var goPartitionBuffer PartitionInfoMsg
	cPartitionBuffer := C.get_partition_info()
	goPartitionBuffer.RecordCount = uint32(cPartitionBuffer.record_count)
	goPartitionBuffer.PartitionInfoList = make([]pbslurm.PartitionInfo, cPartitionBuffer.record_count, cPartitionBuffer.record_count)

	for i := uint32(0); i < goPartitionBuffer.RecordCount; i++ {
		partition := C.partition_from_list(cPartitionBuffer, C.int(i))
		goPartition := PartitionDescriptorConvertCToGo(partition)
		goPartitionBuffer.PartitionInfoList[i] = goPartition
	}
	return goPartitionBuffer
}

func PartitionDescriptorConvertCToGo(cStruct *C.struct_partition_info) pbslurm.PartitionInfo {
	var goStruct pbslurm.PartitionInfo
	goStruct.Name = C.GoString(cStruct.name)
	return goStruct
}

func (slurmStruct SlurmStruct) GetPartition(ctx context.Context, req *pbslurm.GetPartitionReq) (*pbslurm.GetPartitionResp, error) {
	PartitionList := GetPartitionsInfo()
	resp := pbslurm.GetPartitionResp{}
	for _, partition := range PartitionList.PartitionInfoList {
		partitionInfoResult := partition
		if strings.Contains(partition.Name, req.PartitionName) {
			resp.PartitionInfos = append(resp.PartitionInfos, &partitionInfoResult)
		}
	}
	return &resp, nil
}