package dto

import (
	"encoding/json"
	"fmt"
	"knowledge/api/model"
	"knowledge/utils"
)

// QuestionQaDto 问答题库
type QuestionQaDto struct {
	QaId                 string                     `json:"qa_id"`                  // 主键id
	QaName               string                     `json:"qa_name"`                // 名称
	QaType               int                        `json:"qa_type"`                // 题库类型（1:常规模式 2:固定套题模式 3:多轮固定题型模式）
	QaQuantity           int                        `json:"qa_quantity"`            // 题目数量
	QaStatus             int                        `json:"qa_status"`              // 状态（1:正常 2:无效）
	TokenNum             *int                       `json:"token_num"`              // 飞花令数量（当题库类型为2、3时存在）
	RoundNum             *int                       `json:"round_num"`              // 轮次数量（当题库类型为3时存在）
	QaRuleContent        string                     `json:"qa_rule_content"`        // 规则解释
	QaDisplayType        int                        `json:"qa_display_type"`        // 展示类型（1:常规 2:飞花令）
	QaExpireTime         *model.LocalTime           `json:"qa_expire_time"`         // 过期时间
	QaShareId            string                     `json:"qa_share_id"`            // 分享标识
	QaPassword           string                     `json:"qa_password"`            // 分享密码
	OpenNumber           int                        `json:"open_number"`            // 打开的次数
	Image                string                     `json:"image"`                  // 背景图
	ItemContent          []ItemContentDto           `json:"item_content"`           // 明细选题（json）
	QuestionQaToken      []*QuestionQaTokenDto      `json:"base_token_item"`        // 飞花令明细 展示类型为飞花令时存在
	TokenQuestionContent []*TokenQuestionContentDto `json:"token_question_content"` // 飞花令题目数量规则（当题库类型为2、3时存在。2表示飞花令后固定题目数量，3表示飞花令后单个类型题目数量）
	CreatedAt            model.LocalTime            `json:"created_at"`             // 创建时间
	UpdatedAt            model.LocalTime            `json:"updated_at"`             // 更新时间
}

// QuestionQaBaseTokenItem 问答题库-飞花令明细
type QuestionQaBaseTokenItem struct {
	TokenId string `json:"token_id"  form:"token_id" label:"飞花令明细id" validate:"required"`
}

// ItemContentDto 问答题库-明细选题规则
type ItemContentDto struct {
	QuestionType  int    `json:"question_type"`   // 题目类型(1:单选 2:多选 3:问答 4:判断)
	FirstLabelId  string `json:"first_label_id"`  // 一级标签id
	SecondLabelId string `json:"second_label_id"` // 二级标签id
	Difficulty    int    `json:"difficulty"`      // 难度（0:未知 1:低 2:中 3:高）
	Quantity      int    `json:"quantity"`        // 数量
}

// TokenQuestionContentDto 问答题库-飞花令题目数量规则
type TokenQuestionContentDto struct {
	QuestionType int `json:"question_type"` // 题目类型(1:单选 2:多选 3:问答 4:判断)
	Quantity     int `json:"quantity"`      // 数量
}

// GetQuestionQaListDto 问答题库列表
func GetQuestionQaListDto(m []*model.QuestionQa) []*QuestionQaDto {
	// 处理返回值
	responses := make([]*QuestionQaDto, len(m))

	if len(m) > 0 {
		for i, v := range m {
			response := &QuestionQaDto{
				QaId:          fmt.Sprintf("%d", v.QaId),
				QaName:        v.QaName,
				QaType:        v.QaType,
				QaQuantity:    v.QaQuantity,
				QaStatus:      v.QaStatus,
				QaRuleContent: v.QaRuleContent,
				QaDisplayType: v.QaDisplayType,
				QaExpireTime:  &v.QaExpireTime,
				QaShareId:     utils.AddDomain(v.QaShareId),
				QaPassword:    v.QaPassword,
				Image:         utils.AddOssDomain(v.Image),
				OpenNumber:    v.OpenNumber,
				CreatedAt:     v.CreatedAt,
				UpdatedAt:     v.UpdatedAt,
			}

			// 加载飞花令数量（当题库类型为2、3时存在）
			if v.TokenNum != nil {
				response = response.LoadTokenNum(v.TokenNum)
			}

			// 加载轮次数量（当题库类型为3时存在）
			if v.RoundNum != nil {
				response = response.LoadRoundNum(v.RoundNum)
			}

			// 将转换后的结构体添加到新切片中
			responses[i] = response
		}
	}

	return responses
}

// GetQuestionQaDto 问答题库详情
func GetQuestionQaDto(m *model.QuestionQa) *QuestionQaDto {
	return &QuestionQaDto{
		QaId:          fmt.Sprintf("%d", m.QaId),
		QaName:        m.QaName,
		QaType:        m.QaType,
		QaQuantity:    m.QaQuantity,
		QaStatus:      m.QaStatus,
		QaRuleContent: m.QaRuleContent,
		QaDisplayType: m.QaDisplayType,
		QaExpireTime:  &m.QaExpireTime,
		QaShareId:     utils.AddDomain(m.QaShareId),
		QaPassword:    m.QaPassword,
		OpenNumber:    m.OpenNumber,
		Image:         utils.AddOssDomain(m.Image),
		CreatedAt:     m.CreatedAt,
		UpdatedAt:     m.UpdatedAt,
	}
}

// LoadItemContent 加载明细选题规则
func (r *QuestionQaDto) LoadItemContent(s string) *QuestionQaDto {
	if s != "" {
		var itemContentDto []ItemContentDto

		err := json.Unmarshal([]byte(s), &itemContentDto)
		if err == nil {
			r.ItemContent = itemContentDto
		}
	}
	return r
}

// LoadQuestionQaToken 加载飞花令数据
func (r *QuestionQaDto) LoadQuestionQaToken(m []*model.QuestionQaToken) *QuestionQaDto {
	if len(m) > 0 {
		r.QuestionQaToken = GetQuestionQaTokenListDto(m)
	}
	return r
}

// LoadTokenNum 加载飞花令数量（当题库类型为2、3时存在）
func (r *QuestionQaDto) LoadTokenNum(s *int) *QuestionQaDto {
	if s != nil {
		r.TokenNum = s
	}
	return r
}

// LoadRoundNum 加载轮次数量（当题库类型为3时存在）
func (r *QuestionQaDto) LoadRoundNum(s *int) *QuestionQaDto {
	if s != nil {
		r.RoundNum = s
	}
	return r
}

// LoadQaQuestionQuantityContent 加载飞花令题目数量规则（当题库类型为2、3时存在。2表示飞花令后固定题目数量，3表示飞花令后单个类型题目数量）
func (r *QuestionQaDto) LoadQaQuestionQuantityContent(s string) *QuestionQaDto {
	if s != "" {
		var tokenQuestionContentDto []*TokenQuestionContentDto

		err := json.Unmarshal([]byte(s), &tokenQuestionContentDto)
		if err == nil {
			r.TokenQuestionContent = tokenQuestionContentDto
		}
	}
	return r
}