package dao

import (
	"encoding/json"
	"errors"
	"micro-bundle/internal/model"
	"micro-bundle/pb/bundle"
	"micro-bundle/pkg/app"
	"micro-bundle/pkg/msg"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

func SendQuestionnaireSurvey(req *bundle.SendQuestionnaireSurveyRequest) (resp *bundle.SendQuestionnaireSurveyResponse, err error) {
	resp = new(bundle.SendQuestionnaireSurveyResponse)
	userInfo := &model.UserInfo{}
	err = app.ModuleClients.BundleDB.Raw(`
		SELECT 
			mau.id as user_id,
			mau.sub_num as user_num,
			mau.tel_num as user_tel,
			marn.name as user_name
		from `+"`micro-account`.`user`"+` as mau
		left join `+"`micro-account`.`real_name`"+` as marn on marn.id = mau.real_name_id and marn.deleted_at = 0
		where mau.deleted_at = 0 and mau.tel_num = ?
		`, req.UserTel).Scan(&userInfo).Error
	if err != nil {
		return resp, err
	}
	if userInfo.UserId == 0 {
		resp.Status = 1
		return resp, nil
	}
	questionnaireInfo := &model.QuestionnaireSurvey{}
	err = app.ModuleClients.BundleDB.Model(&model.QuestionnaireSurvey{}).
		Where("user_tel = ? and deleted_at is null", req.UserTel).
		Order("created_at desc").
		First(&questionnaireInfo).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			resp.Status = 0
		} else {
			return resp, err
		}
	}
	if questionnaireInfo.UserId != 0 {
		if questionnaireInfo.SurveyStatus == msg.QuestionnaireSent {
			resp.Status = 0
			return resp, nil
		}
		resp.Status = 2
		return resp, nil
	}
	orderRecord := &model.BundleOrderRecords{}
	err = app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).
		Where("customer_num = ? and deleted_at is null", userInfo.UserNum).
		Order("created_at desc").
		First(&orderRecord).Error
	if err != nil {
		return resp, err
	}

	bundleBalance := &model.BundleBalance{}
	month := timeParse(req.EndTime + " 23:59:59").Format("2006-01")
	err = app.ModuleClients.BundleDB.Model(&model.BundleBalance{}).
		Where("order_uuid = ? and deleted_at is null", orderRecord.UUID).
		Where("month = ?", month).
		First(&bundleBalance).Error
	if err != nil {
		return resp, err
	}
	bundleInfo := &model.BundleInfo{
		BundleName:              orderRecord.BundleName,
		StartAt:                 bundleBalance.StartAt,
		ExpiredAt:               bundleBalance.ExpiredAt,
		BundleAccountNumber:     3,
		BundleVideoNumber:       bundleBalance.BundleLimitVideoConsumptionNumber,
		IncreaseVideoNumber:     bundleBalance.IncreaseVideoConsumptionNumber,
		BundleImageNumber:       bundleBalance.BundleLimitImageConsumptionNumber,
		BundleDataNumber:        bundleBalance.BundleLimitDataAnalysisConsumptionNumber,
		BundleCompetitiveNumber: bundleBalance.BundleLimitCompetitiveConsumptionNumber,
	}
	bundleInfoJSON, err := json.Marshal(bundleInfo)
	if err != nil {
		return resp, err
	}
	data := &model.QuestionnaireSurvey{
		SurveyUUID:   uuid.New().String(),
		UserId:       userInfo.UserId,
		UserNum:      userInfo.UserNum,
		UserName:     userInfo.UserName,
		UserTel:      userInfo.UserTel,
		OrderUUID:    orderRecord.UUID,
		SendTime:     timeParse(time.Now().Format("2006-01-02 15:04:05")),
		SubmitTime:   timeParse(time.Now().Format("2006-01-02 15:04:05")),
		SurveyStatus: msg.QuestionnaireSent,
		BundleInfo:   string(bundleInfoJSON),
		SurveyTitle:  req.SurveyTitle,
	}
	err = app.ModuleClients.BundleDB.Model(&model.QuestionnaireSurvey{}).Create(data).Error
	if err != nil {
		return resp, err
	}
	resp.Status = 0
	return resp, nil
}

func GetQuestionnaireSurveyInfo(req *bundle.GetQuestionnaireSurveyInfoRequest) (data *model.QuestionnaireSurvey, err error) {
	data = &model.QuestionnaireSurvey{}
	err = app.ModuleClients.BundleDB.Model(&model.QuestionnaireSurvey{}).
		Where("user_tel = ? and deleted_at is null", req.UserTel).
		Order("created_at desc").
		First(&data).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("问卷信息不存在")
		}
		return data, err
	}
	return data, nil
}

func CreateQuestionnaireSurveyAnswer(req *bundle.CreateQuestionnaireSurveyAnswerRequest) (err error) {
	surveyAnswer := &model.SurveyAnswer{
		BundleAccountScore:          req.SurveyAnswer.BundleAccountScore,
		BundleVideoScore:            req.SurveyAnswer.BundleVideoScore,
		IncreaseVideoScore:          req.SurveyAnswer.IncreaseVideoScore,
		BundleImageScore:            req.SurveyAnswer.BundleImageScore,
		BundleDataScore:             req.SurveyAnswer.BundleDataScore,
		BundleCompetitiveScore:      req.SurveyAnswer.BundleCompetitiveScore,
		ServiceResponseSpeed:        req.SurveyAnswer.ServiceResponseSpeed,
		ServiceStaffProfessionalism: req.SurveyAnswer.ServiceStaffProfessionalism,
	}
	surveyAnswerJSON, err := json.Marshal(surveyAnswer)
	if err != nil {
		return err
	}
	err = app.ModuleClients.BundleDB.Model(&model.QuestionnaireSurvey{}).
		Where("user_tel = ? and deleted_at is null", req.UserTel).
		Updates(map[string]interface{}{
			"survey_answer":              string(surveyAnswerJSON),
			"merits_review":              req.SurveyFeedback.MeritsReview,
			"suggestionsor_improvements": req.SurveyFeedback.SuggestionsorImprovements,
			"additional_comments":        req.SurveyFeedback.AdditionalComments,
			"submit_time":                timeParse(time.Now().Format("2006-01-02 15:04:05")),
			"survey_status":              msg.QuestionnaireSubmitted,
			"survey_url":                 req.SurveyUrl,
			"submit_by":                  req.SubmitBy,
		}).Error
	if err != nil {
		return err
	}
	return nil
}

func GetQuestionnaireSurveyList(req *bundle.GetQuestionnaireSurveyListRequest) (data []*model.QuestionnaireSurvey, total int64, err error) {
	if req.Page == 0 {
		req.Page = 1
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}
	query := app.ModuleClients.BundleDB.Model(&model.QuestionnaireSurvey{})
	if req.UserName != "" {
		query = query.Where("user_name = ?", req.UserName)
	}
	if req.SurveyTitle != "" {
		query = query.Where("survey_title = ?", req.SurveyTitle)
	}
	if req.SurveyStatus != 0 {
		query = query.Where("survey_status = ?", req.SurveyStatus)
	}
	query = query.Order("created_at desc")
	query.Count(&total)
	query = query.Limit(int(req.PageSize)).Offset(int(req.Page-1) * int(req.PageSize))
	err = query.Find(&data).Error
	if err != nil {
		return data, total, err
	}
	return data, total, nil
}