package main

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"os"
	"regexp"
	"strconv"
	"strings"
	"time"

	pmschema "ems.agt/crontask/pm/schema"
	"ems.agt/lib/global"
	"ems.agt/lib/log"

	"gopkg.in/yaml.v3"
)

var (
	neTypes = []string{"AMF", "SMF", "UDM", "UPF", "AUSF"}
)

func (t *TaskFunc) GenPmXmlFile(uri, params, body string) {
	for _, neType := range neTypes {
		log.Debugf("GenPmXmlFile process %s xml file", neType)
		t.GenNFPMXmlFile(neType)
	}
}

func (t *TaskFunc) ReadPmYaml(cmfile string) (map[string]interface{}, error) {
	log.Debug("cmfile:", cmfile)
	file, err := ioutil.ReadFile(cmfile)
	if err != nil {
		log.Error(err)
		return nil, err
	}
	log.Debug("file:", file)
	resultMap := make(map[string]interface{})
	err = yaml.Unmarshal(file, resultMap)
	if err != nil {
		log.Error(err)
		return nil, err
	}

	log.Debug("resultMap:", resultMap)
	return resultMap, nil
}

func (t *TaskFunc) IsPseudoSubPmName(pmName string) bool {
	return strings.Contains(pmName, "._")
}

func (t *TaskFunc) GenNFPMXmlFile(neType string) error {
	var nes []NeInfo
	_, err := XormGetNeInfoByType(neType, &nes)
	if err != nil {
		log.Error("Failed to get all ne info:", err)
		return err
	}

	//	cfile := fmt.Sprintf("%s/pm-%s.yaml", yamlConfig.NBI.PM.CfgFileDir, strings.ToLower(neType))

	//	resultMap, _ := t.ReadPmYaml(cfile)

	ti := time.Now()
	var startTime string
	timestamp := ti.Format("2006-01-02 15:04:05")

	index := global.GetCurrentTimeSliceIndexByPeriod(ti, 15)
	date := time.Now().Format("2006-01-02")
	log.Debugf("date: %s index:%d", date, index)

	_, offset := ti.Zone()
	var tzOffset string
	if offset >= 0 {
		tzOffset = "UTC+" + strconv.Itoa(offset/3600)
	} else {
		tzOffset = "UTC" + strconv.Itoa(offset/3600)
	}

	pmFile := new(pmschema.PmFile)

	var pms []NorthboundPm
	_, err = XormGetNorthboundPm(date, index, neType, &pms)
	if err != nil {
		log.Error("Failed to get northbound_pm:", err)
		return err
	}

	if len(pms) == 0 {
		log.Errorf("%s:%v", neType, global.ErrPMNotFoundData)
		return global.ErrPMNotFoundData
	}

	pmFile.XsAttr = "http://www.w3.org/2001/XMLSchema"
	pmFile.XsiAttr = "http://www.w3.org/2001/XMLSchema-instance"
	/*
		objectTypes := make([]string, 0)
		sortValues := make(map[string]interface{})
		keys := make([]string, 0)
		if len(pms) > 0 {
			for _, data := range pms[0].Datas {
				for _, pmData := range data.PmDatas {
					sortValues[pmData.PmName] = pmData.SubDatas
					keys = append(keys, pmData.PmName)
				}
				objectTypes = append(objectTypes, data.ObjectType)
			}
			sort.Strings(keys)
			sort.Strings(objectTypes)
		}
		log.Debug("objectTypes:", objectTypes)
		log.Debug("keys:", keys)
	*/
	var measurement pmschema.Measurements
	for _, pm := range pms {
		for _, pdata := range pm.Datas {
			measurement = pmschema.Measurements{ObjectType: pdata.ObjectType}
			measurement.PmData.Object.RmUIDAttr = pm.RmUID
			measurement.PmData.Object.DnAttr = pm.Dn
			measurement.PmData.Object.UserLabelAttr = pm.NeName
			startTime = pm.StartTime

			i := 1
			for _, pmData := range pdata.KPIs {
				measurement.PmName.N = append(measurement.PmName.N, pmschema.N{IAttr: i, Value: pmData.KPIID})
				cv := pmschema.CV{IAttr: i}
				isPseudo := true
				value := "0"
				reg := regexp.MustCompile(`_\w+`)
				//sns := strings.Split(pmData.KPIID, "_")
				for _, v := range pmData.KPIValues {
					if fmt.Sprintf("%v", v.Name) == "Total" {
						isPseudo = false
						value = fmt.Sprintf("%v", v.Value)
						break
					} else {
						isPseudo = true
						//if len(sns) > 1 {
						//	sns := strings.Split(sns[1], ".")
						//}
						sn := reg.ReplaceAllString(pmData.KPIID, v.Name)
						//sn := sns[0] + v.Name
						// cv.NV = append(cv.NV, pmschema.NV{SN: sn, SV: fmt.Sprintf("%v", v.Value)})
						cv.SN = append(cv.SN, sn)
						cv.SV = append(cv.SV, fmt.Sprintf("%v", v.Value))
					}
				}
				if isPseudo == false {
					measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: value})
				} else {
					measurement.PmData.Object.CV = append(measurement.PmData.Object.CV, cv)
				}

				i++
				//measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: sortValues[pmName].Value})
				//measurement.PmData.Object.CV = sortValues[pmName].Value
			}
			pmFile.Measurements = append(pmFile.Measurements, measurement)

		}
	}

	pmFile.FileHeader = pmschema.FileHeader{
		TimeStamp:   timestamp,
		TimeZone:    tzOffset,
		Period:      15,
		VendorName:  "Ruijie Network",
		ElementType: neType,
		PmVersion:   global.Version,
		StartTime:   startTime,
	}
	/*
		for _, obj := range objectTypes {
			measurement := pmschema.Measurements{ObjectType: obj}

			for _, pm := range pms {
				measurement.PmData.Object.RmUIDAttr = pm.RmUID
				measurement.PmData.Object.DnAttr = pm.Dn
				measurement.PmData.Object.UserLabelAttr = pm.NeName
				for _, pdata := range pm.Datas {
					measurement := pmschema.Measurements{ObjectType: pdata.ObjectType}
					if pdata.ObjectType == obj {
						i := 1
						for _, pmName := range keys {
							measurement.PmName.N = append(measurement.PmName.N, pmschema.N{IAttr: i, Value: pmName})
							measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: "1"})
							i++
							//measurement.PmData.Object.V = append(measurement.PmData.Object.V, pmschema.V{IAttr: i, Value: sortValues[pmName].Value})
							//measurement.PmData.Object.CV = sortValues[pmName].Value
						}
					}
				}
			}
			pmFile.Measurements = append(pmFile.Measurements, measurement)
		}
	*/

	/*
		for k, pm := range pms {
			measurement := pmschema.Measurements{ObjectType: "gold_kpi"}

			for s, ne := range nes {
				rmUID := fmt.Sprintf("01000HX%sBJ0D0%d", neType, s+1)
				vmId := fmt.Sprintf("kylin10.0-00%d-%s", s+1, neType)
				measurement.PmName.
				vnfInstanceID := fmt.Sprintf("2%xd55b4-%d018-41f4-af%d5-28b%d828788", s+10, s+6, s+4, s+3)
				object := pmschema.Object{RmUIDAttr: rmUID,
					DnAttr:        "DC=www.ruijie.com.cn,SubNetwork=10001,SubNetwork=114214,ManagedElement=325",
					UserLabelAttr: ne.NeName, PVFlagAttr: ne.PvFlag, VMIDAttr: vmId, VNFInstanceIDAttr: vnfInstanceID}

				i := 1
				for _, p := range keys {
					if s == 0 {
						objects.FieldName.N = append(objects.FieldName.N, pmschema.N{IAttr: i, Value: p})
					}
					var v string
					switch p {
					case "Id":
						v = ne.NeId
					case "UserLabel":
						v = ne.NeName
					case "VendorName":
						v = "Ruijie Network"
					case "SwVersion":
						v = global.Version
					case "PatchInfo":
						v = "-"
					case "AdministrativeState":
						v = AdminStateUnlocked
					case "OperationalState":
						v = OperationStateEnabled
					case "VnfInstanceId":
						v = vnfInstanceID
					default:
						if sortResult[p] == "" {
							v = "-"
						} else {
							v = fmt.Sprintf("%s", sortResult[p])
						}
					}
					object.V = append(object.V, cmschema.V{IAttr: i, Value: v})
					i++
				}
				objects.FieldValue.Object = append(objects.FieldValue.Object, object)
			}
			pmFile.Measurements = append(pmFile.Measurements, measurement)
		}
	*/

	x, _ := xml.MarshalIndent(pmFile, "", "	")
	x = append([]byte(xml.Header), x...)

	folderName := global.GetFmtTimeString(global.DateTime, startTime, global.DateHour)
	folderPath := global.CreateDir(folderName, yamlConfig.NBI.PM.XmlFileDir)
	timefile := global.GetFmtTimeString(global.DateTime, startTime, global.DateData)
	xmlfile := fmt.Sprintf("%s/PM-%s-%s-%s-15-001.xml", folderPath, neType, global.Version, timefile)
	log.Debugf("folderPath:%s, xmlfile:%s", folderPath, xmlfile)
	err = os.WriteFile(xmlfile, x, 0664)
	if err != nil {
		log.Error("Failed to write xml file:", err)

		return err
	}
	return nil
}