package dao

import (
	"errors"
	"gorm.io/gorm"
	"knowledge/api/model"
	"knowledge/api/requests"
	"knowledge/global"
)

type QuestionQaItemDao struct {
}

// GetQuestionQaItemById 获取数据-id
func (r *QuestionQaItemDao) GetQuestionQaItemById(itemId int64) (m *model.QuestionQaItem, err error) {
	err = global.Db.First(&m, itemId).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemListByQaId 获取数据-QaId
func (r *QuestionQaItemDao) GetQuestionQaItemListByQaId(qaId int64) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where("qa_id = ?", qaId).Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// DeleteQuestionQaItem 删除
func (r *QuestionQaItemDao) DeleteQuestionQaItem(tx *gorm.DB, maps interface{}) error {
	err := tx.Where(maps).Delete(&model.QuestionQaItem{}).Error
	if err != nil {
		return err
	}
	return nil
}

// DeleteQuestionQaItemById 删除-Id
func (r *QuestionQaItemDao) DeleteQuestionQaItemById(tx *gorm.DB, itemId int64) error {
	if err := tx.Delete(&model.QuestionQaItem{}, itemId).Error; err != nil {
		return err
	}
	return nil
}

// DeleteQuestionQaItemByQaId 删除-QaId
func (r *QuestionQaItemDao) DeleteQuestionQaItemByQaId(tx *gorm.DB, qaId int64) error {
	if err := tx.Where("qa_id = ?", qaId).Delete(&model.QuestionQaItem{}).Error; err != nil {
		return err
	}
	return nil
}

// EditQuestionQaItem 修改
func (r *QuestionQaItemDao) EditQuestionQaItem(tx *gorm.DB, maps interface{}, data interface{}) error {
	err := tx.Model(&model.QuestionQaItem{}).Where(maps).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}

// EditQuestionQaItemById 修改-id
func (r *QuestionQaItemDao) EditQuestionQaItemById(tx *gorm.DB, itemId int64, data interface{}) error {
	err := tx.Model(&model.QuestionQaItem{}).Where("item_id = ?", itemId).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}

// GetQuestionQaItemList 获取列表
func (r *QuestionQaItemDao) GetQuestionQaItemList(maps interface{}) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where(maps).Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemListRand 获取列表-随机
func (r *QuestionQaItemDao) GetQuestionQaItemListRand(maps interface{}, limit int) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where(maps).Limit(limit).Order("rand()").Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// AddQuestionQaItem 新增
func (r *QuestionQaItemDao) AddQuestionQaItem(tx *gorm.DB, model *model.QuestionQaItem) (*model.QuestionQaItem, error) {
	if err := tx.Create(model).Error; err != nil {
		return nil, err
	}
	return model, nil
}

// GetQuestionQaItem 获取
func (r *QuestionQaItemDao) GetQuestionQaItem(maps interface{}) (m *model.QuestionQaItem, err error) {
	err = global.Db.Where(maps).First(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemPageSearch 获取列表-分页
func (r *QuestionQaItemDao) GetQuestionQaItemPageSearch(req requests.GetQuestionQaItemPage, page, pageSize int) (m []*model.QuestionQaItem, total int64, err error) {
	var totalRecords int64

	// 构建查询条件
	query := global.Db.Model(&model.QuestionQaItem{})

	// 题目表
	query = query.Preload("Question", func(db *gorm.DB) *gorm.DB {
		return db.Select("question_id", "question_name", "question_type", "question_source", "difficulty", "first_label_id", "second_label_id")
	})

	// 一级标签
	query = query.Preload("Question.FirstLabel", func(db *gorm.DB) *gorm.DB {
		return db.Select("label_id", "label_name")
	})

	// 二级标签
	query = query.Preload("Question.SecondLabel", func(db *gorm.DB) *gorm.DB {
		return db.Select("label_id", "label_name")
	})

	// 题库id
	query = query.Where("qa_id = ?", req.QaId)

	// 题目id
	if req.QuestionId != "" {
		query = query.Where("question_id = ?", req.QuestionId)
	}

	// 是否必被选中
	if req.IsMustSelect != nil {
		query = query.Where("is_must_select = ?", req.IsMustSelect)
	}

	// 题目名称
	if req.QuestionName != "" {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_name LIKE ?", "%"+req.QuestionName+"%")

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 题目类型
	if req.QuestionType != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_type = ?", req.QuestionType)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 题目来源
	if req.QuestionSource != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_source = ?", req.QuestionSource)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 难度
	if req.Difficulty != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("difficulty = ?", req.Difficulty)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 一级标签id
	if req.FirstLabelId != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("first_label_id = ?", req.FirstLabelId)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 二级标签id
	if req.SecondLabelId != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("second_label_id = ?", req.SecondLabelId)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 排序
	if req.Order != nil {
		if req.Order.UpdatedAt != "" {
			if req.Order.UpdatedAt != "desc" && req.Order.UpdatedAt != "asc" {
				return nil, 0, errors.New("排序字段错误")
			}

			query = query.Order("updated_at " + req.Order.UpdatedAt)
		}
	}

	// 排序
	query = query.Order("created_at desc")

	// 查询总数量
	if err := query.Count(&totalRecords).Error; err != nil {
		return nil, 0, err
	}

	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
	if err != nil {
		return nil, 0, err
	}
	return m, totalRecords, nil
}