package service

import (
	"errors"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/model"
)

type QuestionService struct {
}

// GetHotList 获取算一算热榜-人气数最高的9个
func (r *QuestionService) GetHotList() (m []*model.Question, err error) {
	questionDao := dao.QuestionDao{}

	maps := make(map[string]interface{})
	maps["question_status"] = 1
	maps["is_hide"] = 0
	questions, err := questionDao.GetQuestionOrderLimitList(maps, "click_count desc", 9)
	if err != nil {
		return nil, err
	}

	return questions, nil
}

// GetRecommendList 获取为你推荐-后台指定的推广
func (r *QuestionService) GetRecommendList() (m []*model.Question, err error) {
	questionDao := dao.QuestionDao{}

	maps := make(map[string]interface{})
	maps["question_status"] = 1
	maps["is_hide"] = 0
	maps["is_recommend"] = 1
	questions, err := questionDao.GetQuestionList(maps)
	if err != nil {
		return nil, err
	}

	return questions, nil
}

// GetGuessUserLIkeList 获取猜你喜欢-暂用公众参与过的最新算一算，至多显示3个。若未参与，则指定或者随机显示3个
func (r *QuestionService) GetGuessUserLIkeList(userId int64) (m []*model.Question, err error) {
	orderSingleDao := dao.OrderSingleDao{}
	questionDao := dao.QuestionDao{}

	var questions []*model.Question

	if userId != 0 {
		maps := make(map[string]interface{})
		maps["user_id"] = userId
		orderSingles, err := orderSingleDao.GetOrderSingleOrderList(maps, "created_at desc", 3)
		if err != nil {
			return nil, err
		}

		// 参与过
		if len(orderSingles) > 0 {
			for i, single := range orderSingles {
				questions[i] = single.Question
			}
		}
	}

	// 未参与过/未指定用户
	if len(questions) == 0 {
		maps := make(map[string]interface{})
		maps["question_status"] = 1
		maps["is_hide"] = 0
		questions, err = questionDao.GetQuestionListRand(maps, 3)
		if err != nil {
			return nil, err
		}
	}

	return questions, nil
}

// CheckUserCollectionQuestion 检测问题是否被用户收藏
func (r *QuestionService) CheckUserCollectionQuestion(userId, questionId int64) (bool, error) {
	userCollectionDao := dao.UserCollectionDao{}

	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["question_id"] = questionId
	userCollection, err := userCollectionDao.GetUserCollection(maps)
	if userCollection == nil {
		return false, err
	}

	return true, nil
}

// CheckUserBuyQuestion 检测用户是否购买过该问题
func (r *QuestionService) CheckUserBuyQuestion(userId, questionId int64) bool {
	orderSingleDao := dao.OrderSingleDao{}
	orderSingle, _ := orderSingleDao.GetUserFirstTimeBuyOrderSingle(userId, questionId)
	if orderSingle == nil {
		return false
	}

	return true
}

// GetUserFirstTimeBuyPrice 获取用户首次购买价格
func (r *QuestionService) GetUserFirstTimeBuyPrice(userId, questionId int64) (f *float64, err error) {
	// 检测用户是否购买过该问题
	isFirstBuy := r.CheckUserBuyQuestion(userId, questionId)
	if isFirstBuy == false {
		// 未购买过
		systemSingleDao := dao.SystemSingleDao{}

		maps := make(map[string]interface{})
		systemSingle, err := systemSingleDao.GetSystemSingle(maps)
		if err != nil {
			return nil, err
		}

		return &systemSingle.FirstTimePrice, nil
	}

	return nil, nil
}

// GetQuestionBuyCount 获取问题被购买数量
func (r *QuestionService) GetQuestionBuyCount(userId, questionId int64) (c int, err error) {
	// 未购买过
	systemSingleDao := dao.SystemSingleDao{}

	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["question_id"] = questionId
	maps["order_status"] = 2
	maps["refund_status"] = 0
	buyCount, err := systemSingleDao.GetSystemSingleCount(maps)
	if err != nil {
		return 0, err
	}

	return int(buyCount), nil
}

// GetUserBuyPrice 获取问题价格
func (r *QuestionService) GetUserBuyPrice(userId, questionId int64) (p float64, err error) {
	// 获取问题详情
	questionDao := dao.QuestionDao{}
	question, err := questionDao.GetQuestionById(questionId)
	if err != nil {
		return 0, errors.New("题目异常")
	}

	// 问题价格
	p = question.Price

	if question.DiscountPrice != nil {
		p = *question.DiscountPrice
	}

	// 检测用户是否购买过该问题
	isFirstBuy := r.CheckUserBuyQuestion(userId, questionId)
	if isFirstBuy == false {
		// 未购买过
		systemSingleDao := dao.SystemSingleDao{}

		maps := make(map[string]interface{})
		systemSingle, err := systemSingleDao.GetSystemSingle(maps)
		if err != nil {
			return 0, err
		}

		p = systemSingle.FirstTimePrice
	}

	return p, nil
}

// CheckQuestion 检测题目
func (r *QuestionService) CheckQuestion(m *model.Question) (bool, error) {
	if m.QuestionStatus != 1 {
		return false, errors.New("题目异常")
	}

	if m.IsHide != 0 {
		return false, errors.New("题目异常")
	}

	return true, nil
}