package graph

import (
	"fmt"
	"strings"

	"github.com/golang-module/carbon"
	"github.com/samber/lo"
	"gogs.uu.mdfitnesscao.com/cuiguohai/sdk"
	"gogs.uu.mdfitnesscao.com/cuiguohai/sdk/response"
	"gogs.uu.mdfitnesscao.com/cuiguohai/sdk/utils"
)

// 获取节点列表，并转成问题模板的格式返回
func ListNodeToQuestionTemplate(ids []string, needCheckItemId bool) ([]*sdk.QuestionnaireTemplate, *response.ErrCode) {
	response, err := ListNode(ids, []string{})
	if err != nil {
		return nil, err
	}
	list := response.Data.List
	var questionTemplates []*sdk.QuestionnaireTemplate = make([]*sdk.QuestionnaireTemplate, 0)
	for _, item := range list {
		questionTemplates = append(questionTemplates, FormatNodeToSurveyQuestionTemplate(item, needCheckItemId))
	}

	return questionTemplates, nil
}

func GetNodeRelationShipsToStruct(id, name string) ([]*sdk.QuestionnaireSubjectSelectValue, []*sdk.QuestionnaireSubjectSelectValue) {
	response, err := GetNodeRelationShip(id, name, "")
	if err != nil {
		return nil, nil
	}
	relationShips := response.Data
	// 单位列表
	var unitValues []*sdk.QuestionnaireSubjectSelectValue = make([]*sdk.QuestionnaireSubjectSelectValue, 0)
	// 范围列表
	var rangeValues []*sdk.QuestionnaireSubjectSelectValue = make([]*sdk.QuestionnaireSubjectSelectValue, 0)
	for _, relation := range relationShips {
		unitValues = append(unitValues, &sdk.QuestionnaireSubjectSelectValue{
			Value: relation["mProperties"].(map[string]any)["name"].(string),
			Label: relation["mProperties"].(map[string]any)["name"].(string),
		})
		// 判断properties是否有“参考范围”这个属性
		if _, ok := relation["properties"].(map[string]any)["参考范围"]; ok {
			rangeValues = append(rangeValues, &sdk.QuestionnaireSubjectSelectValue{
				Value: relation["properties"].(map[string]any)["参考范围"].(string),
				Label: relation["properties"].(map[string]any)["参考范围"].(string),
			})
		}
	}

	return unitValues, rangeValues
}

func FormatNodeToSurveyQuestionTemplate(graphNode *sdk.GraphNode, needCheckItemId bool) *sdk.QuestionnaireTemplate {

	unitValues, rangeValues := GetNodeRelationShipsToStruct(graphNode.ID, "默认单位与范围")

	questionaireTemplate := &sdk.QuestionnaireTemplate{
		SN:           graphNode.ID,
		Title:        graphNode.Properties.Name,
		SubjectTotal: 4,
		SubjectIds: []string{
			fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorValueFlag),
			fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorRangeFlag),
			fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorUnitFlag),
			fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorTimeFlag),
		},
		Subjects: []*sdk.QuestionnaireSubject{
			{
				SN:           fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorValueFlag),
				Type:         sdk.QuestionSubjectTypeInput,
				Title:        "检查结果",
				SelectValues: make([]*sdk.QuestionnaireSubjectSelectValue, 0),
				Validator: utils.JsonEncode(map[string]any{
					"type":        sdk.QuestionSubjectTypeInputFlag,
					"edit":        true,
					"attr":        fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorValueFlag),
					"sn":          fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorValueFlag),
					"remark":      "",
					"combination": "",
					"isRepeat":    false,
					"config": map[string]any{
						"desc":          "",
						"rule":          "",
						"type":          "",
						"regexRule":     "",
						"regexRuleName": "",
					},
					"choices":  []any{},
					"children": []any{},
				}),
			},
			{
				SN:           fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorRangeFlag),
				Type:         sdk.QuestionSubjectTypeInput,
				Title:        "参考范围",
				SelectValues: rangeValues,
				Validator: utils.JsonEncode(map[string]any{
					"type":        sdk.QuestionSubjectTypeInputFlag,
					"edit":        true,
					"attr":        fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorRangeFlag),
					"sn":          fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorRangeFlag),
					"remark":      "",
					"combination": "",
					"isRepeat":    false,
					"config": map[string]any{
						"desc":          "",
						"rule":          "",
						"type":          "",
						"regexRule":     "",
						"regexRuleName": "",
					},
					"choices":  []any{},
					"children": []any{},
				}),
			},
			{
				SN:           fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorUnitFlag),
				Type:         sdk.QuestionSubjectTypeInput,
				Title:        "单位",
				SelectValues: unitValues,
				Validator: utils.JsonEncode(map[string]any{
					"type":        sdk.QuestionSubjectTypeInputFlag,
					"edit":        true,
					"attr":        fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorUnitFlag),
					"sn":          fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorUnitFlag),
					"remark":      "",
					"combination": "",
					"isRepeat":    false,
					"config": map[string]any{
						"desc":          "",
						"rule":          "",
						"type":          "",
						"regexRule":     "",
						"regexRuleName": "",
					},
					"choices":  []any{},
					"children": []any{},
				}),
			},
			{
				SN:           fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorTimeFlag),
				Type:         sdk.QuestionSubjectTypeDate,
				Title:        "检查时间",
				SelectValues: make([]*sdk.QuestionnaireSubjectSelectValue, 0),
				Validator: utils.JsonEncode(map[string]any{
					"type":        sdk.QuestionSubjectTypeDateFlag,
					"edit":        true,
					"attr":        fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorTimeFlag),
					"sn":          fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorTimeFlag),
					"remark":      "",
					"combination": "",
					"isRepeat":    false,
					"config": map[string]any{
						"desc":          "",
						"rule":          "",
						"type":          "",
						"regexRule":     "",
						"regexRuleName": "",
					},
					"choices":  []any{},
					"children": []any{},
				}),
			},
		},
	}

	if needCheckItemId {
		questionaireTemplate.SubjectTotal++
		questionaireTemplate.SubjectIds = append(questionaireTemplate.SubjectIds, fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorCheckItemIdFlag))
		questionaireTemplate.Subjects = append(questionaireTemplate.Subjects, &sdk.QuestionnaireSubject{
			SN:           fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorCheckItemIdFlag),
			Type:         sdk.QuestionSubjectTypeInput,
			Title:        "检查项目",
			SelectValues: make([]*sdk.QuestionnaireSubjectSelectValue, 0),
			Validator: utils.JsonEncode(map[string]any{
				"type":        sdk.QuestionSubjectTypeInputFlag,
				"edit":        true,
				"attr":        fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorCheckItemIdFlag),
				"sn":          fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, graphNode.ID, sdk.IndicatorCheckItemIdFlag),
				"remark":      "",
				"combination": "",
				"isRepeat":    false,
				"isHidden":    true,
				"config": map[string]any{
					"desc":          "",
					"rule":          "",
					"type":          "",
					"regexRule":     "",
					"regexRuleName": "",
				},
				"choices":  []any{},
				"children": []any{},
			}),
		})
	}
	return questionaireTemplate
}

// 提供问题答案列表，过滤出指标的问题答案（返回不是指标的问题，返回指标数据）
func FilterArchivesValues(archivesValuesList []*sdk.ArchivesValues) ([]*sdk.ArchivesValues, []*sdk.Indicator) {
	var indicators []*sdk.Indicator = make([]*sdk.Indicator, 0)
	var surveyAnswers []*sdk.ArchivesValues = make([]*sdk.ArchivesValues, 0)
	var indicatorAnswers []*sdk.ArchivesValues = make([]*sdk.ArchivesValues, 0)
	var nodeIds []string = make([]string, 0)
	for _, archivesValues := range archivesValuesList {
		var answer *sdk.SurveyAnswer
		if archivesValues.ReturnAnswer == nil {
			answer = archivesValues.Answer
		} else {
			answer = archivesValues.ReturnAnswer
		}
		if answer == nil {
			continue
		}

		// 判断是否包含前缀
		if !strings.Contains(answer.QuestionNo, sdk.IndicatorQuestionSubjectPrefix) {
			surveyAnswers = append(surveyAnswers, archivesValues)
			continue
		} else {
			// 将所有属于指标的问题答案过滤出来
			indicatorAnswers = append(indicatorAnswers, archivesValues)
			// 将指标的问题答案的编号过滤出来
			indicatorStrings := strings.Split(answer.QuestionNo, ":")
			if len(indicatorStrings) == 5 {
				nodeIds = append(nodeIds, strings.Join(indicatorStrings[1:4], ":"))
			}
		}
	}

	nodeIds = lo.Uniq(nodeIds)

	// 获取节点列表
	nodeResponse, err := ListNode(nodeIds, []string{})
	var nodeList []*sdk.GraphNode = make([]*sdk.GraphNode, 0)
	if err == nil {
		nodeList = nodeResponse.Data.List
	}

	// 遍历所有的指标问题答案，将其转换成指标数据
	for _, nodeId := range nodeIds {
		var value string    // 指标值
		var rangeStr string // 指标范围
		var unit string     // 指标单位
		var time string     // 指标检查时间
		var name string     // 指标名称
		var itemName string // 指标名称
		var itemId string   // 指标ID
		// 找到对应的节点
		node, finded := lo.Find(nodeList, func(graphNode *sdk.GraphNode) bool {
			return graphNode.ID == nodeId
		})
		if finded {
			name = node.Properties.Name
		}

		// 查询ItemId
		// 检查值
		checkItemValues, finded := lo.Find(indicatorAnswers, func(archivesValues *sdk.ArchivesValues) bool {
			var answer *sdk.SurveyAnswer
			if archivesValues.ReturnAnswer == nil {
				answer = archivesValues.Answer
			} else {
				answer = archivesValues.ReturnAnswer
			}
			if answer == nil {
				return false
			}
			return answer.QuestionNo == fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, nodeId, sdk.IndicatorCheckItemIdFlag)
		})
		if finded {
			var answer *sdk.SurveyAnswer
			if checkItemValues.ReturnAnswer == nil {
				answer = checkItemValues.Answer
			} else {
				answer = checkItemValues.ReturnAnswer
			}
			if answer != nil && len(answer.InputAnswers.Value) > 0 {
				itemId = answer.InputAnswers.Value[0]
				// 查询名称
				response, err := ListNode([]string{itemId}, []string{})
				if err == nil {
					itemName = response.Data.List[0].Properties.Name
				}
			}
		} else {
			// 获取节点列表
			nodeRelationResponse, err := GetNodeRelationd(nodeId, "可检测", "")
			if err == nil {
				if len(nodeRelationResponse.Data) > 0 {
					itemName = nodeRelationResponse.Data[0]["properties"].(map[string]any)["name"].(string)
					itemId = nodeRelationResponse.Data[0]["id"].(string)
				}
			}
		}

		// 检查值
		valueValues, finded := lo.Find(indicatorAnswers, func(archivesValues *sdk.ArchivesValues) bool {
			var answer *sdk.SurveyAnswer
			if archivesValues.ReturnAnswer == nil {
				answer = archivesValues.Answer
			} else {
				answer = archivesValues.ReturnAnswer
			}
			if answer == nil {
				return false
			}
			return answer.QuestionNo == fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, nodeId, sdk.IndicatorValueFlag)
		})
		if finded {
			var answer *sdk.SurveyAnswer
			if valueValues.ReturnAnswer == nil {
				answer = valueValues.Answer
			} else {
				answer = valueValues.ReturnAnswer
			}
			if answer != nil && len(answer.InputAnswers.Value) > 0 {
				value = answer.InputAnswers.Value[0]
			}
		}

		// 检查范围
		rangeValues, finded := lo.Find(indicatorAnswers, func(archivesValues *sdk.ArchivesValues) bool {
			var answer *sdk.SurveyAnswer
			if archivesValues.ReturnAnswer == nil {
				answer = archivesValues.Answer
			} else {
				answer = archivesValues.ReturnAnswer
			}
			if answer == nil {
				return false
			}
			return answer.QuestionNo == fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, nodeId, sdk.IndicatorRangeFlag)
		})
		if finded {
			var answer *sdk.SurveyAnswer
			if rangeValues.ReturnAnswer == nil {
				answer = rangeValues.Answer
			} else {
				answer = rangeValues.ReturnAnswer
			}
			if answer != nil && len(answer.InputAnswers.Value) > 0 {
				rangeStr = answer.InputAnswers.Value[0]
			}
		}
		// 检查单位
		unitValues, finded := lo.Find(indicatorAnswers, func(archivesValues *sdk.ArchivesValues) bool {
			var answer *sdk.SurveyAnswer
			if archivesValues.ReturnAnswer == nil {
				answer = archivesValues.Answer
			} else {
				answer = archivesValues.ReturnAnswer
			}
			if answer == nil {
				return false
			}
			return answer.QuestionNo == fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, nodeId, sdk.IndicatorUnitFlag)
		})
		if finded {
			var answer *sdk.SurveyAnswer
			if unitValues.ReturnAnswer == nil {
				answer = unitValues.Answer
			} else {
				answer = unitValues.ReturnAnswer
			}
			if answer != nil && len(answer.InputAnswers.Value) > 0 {
				unit = answer.InputAnswers.Value[0]
			}
		}

		// 检查时间
		timeValues, finded := lo.Find(indicatorAnswers, func(archivesValues *sdk.ArchivesValues) bool {
			var answer *sdk.SurveyAnswer
			if archivesValues.ReturnAnswer == nil {
				answer = archivesValues.Answer
			} else {
				answer = archivesValues.ReturnAnswer
			}
			if answer == nil {
				return false
			}
			return answer.QuestionNo == fmt.Sprintf("%s:%s:%s", sdk.IndicatorQuestionSubjectPrefix, nodeId, sdk.IndicatorTimeFlag)
		})
		if finded {
			var answer *sdk.SurveyAnswer
			if timeValues.ReturnAnswer == nil {
				answer = timeValues.Answer
			} else {
				answer = timeValues.ReturnAnswer
			}
			if answer != nil {
				time = answer.Answer.Value
			}
		}

		// 检查是否有任意一个参数有值
		if value != "" || rangeStr != "" || unit != "" || time != "" {
			date := 0
			if time != "" {
				date = int(carbon.Parse(time).Carbon2Time().Unix())
			}
			// 开始拼装指标数据
			indicators = append(indicators, &sdk.Indicator{
				ID:        nodeId,
				Name:      name,
				Value:     value,
				Unit:      unit,
				ItemName:  itemName,
				ItemID:    itemId,
				Reference: rangeStr,
				Date:      date,
			})
		}
	}

	return surveyAnswers, indicators
}