package voice_broadcast

import (
	"github.com/gin-gonic/gin"
	"hongze/hongze_yb/controller/response"
	"hongze/hongze_yb/models/request"
	voiceResp "hongze/hongze_yb/models/response"
	"hongze/hongze_yb/models/tables/voice_broadcast"
	"hongze/hongze_yb/models/tables/voice_section"
	"hongze/hongze_yb/services"
	"hongze/hongze_yb/services/company"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/utils"
	"strconv"
	"strings"
)

// BroadcastList
// @Description 语音播报列表
// @Param page_index			query int false "页码"
// @Param page_size				query int false "每页数量"
// @Param broadcast_id			query int false "语音播报id"
// @Param section_id			query int false "板块id"
// @Success 200 {object} []voiceResp.BroadcastListResp
// @failure 400 {string} string "获取失败"
// @Router /list [Post]
func BroadcastList(c *gin.Context) {
	var req request.BroadcastListReq
	if err := c.Bind(&req); err != nil {
		response.Fail("参数有误", c)
		return
	}
	if req.PageIndex == 0 {
		req.PageIndex = 1
	}
	if req.PageSize == 0 {
		req.PageSize = utils.PageSize20
	}

	userinfo := user.GetInfoByClaims(c)
	ok, checkInfo, _, err := company.CheckBaseFiccPermission(userinfo.CompanyID, int(userinfo.UserID))
	if err != nil {
		response.FailMsg("用户权限验证失败", "CheckBaseAuth-用户权限验证失败"+err.Error(), c)
		c.Abort()
		return
	}
	if !ok {
		response.AuthError(checkInfo, "暂无权限", c)
		c.Abort()
		return
	}
	list, err := services.GetVoiceBroadcastList(req.PageIndex, req.PageSize, req.SectionId, req.BroadcastId, userinfo)
	if err != nil {

		response.FailMsg("获取语音播报列表失败，"+err.Error(), "QuestionList ErrMsg:"+err.Error(), c)
		return
	}

	isVoiceAdmin, _, err := services.GetVoiceAdminByUserInfo(userinfo)
	if err != nil && err != utils.ErrNoRow {
		response.FailMsg("获取语音管理员信息失败", "QuestionList ErrMsg:"+err.Error(), c)
		return
	}
	var resp voiceResp.BroadcastListResp
	resp.List = list
	resp.IsVoiceAdmin = isVoiceAdmin
	response.OkData("获取成功", resp, c)
}

// AddBroadcast
// @Description 新建语音播报
// @Param file  query  string  true  "音频文件"
// @Success 200 {string} string "发布成功"
// @failure 400 {string} string "发布失败"
// @Router /add [post]
//func AddBroadcast(c *gin.Context) {
//	broadcastName := c.PostForm("broadcast_name")
//	nsectionId := c.PostForm("section_id")
//	sectionId, _ := strconv.Atoi(nsectionId)
//	sectionName := c.PostForm("section_name")
//	nvarietyId := c.PostForm("variety_id")
//	varietyId, _ := strconv.Atoi(nvarietyId)
//	varietyName := c.PostForm("variety_name")
//	nauthorId := c.PostForm("author_id")
//	authorId, _ := strconv.Atoi(nauthorId)
//	author := c.PostForm("author")
//	imgUrl := c.PostForm("img_url")
//	file, err := c.FormFile("file")
//	if err != nil {
//		response.FailMsg("获取资源失败", "获取资源失败, Err:"+err.Error(), c)
//		return
//	}
//	if imgUrl == "" {
//		response.Fail("图片不能为空", c)
//		return
//	}
//	// 生成动态分享图
//	createTimeStr := time.Now().Local().Format(utils.FormatDate)
//	pars := services.VoiceBroadcastShareImgPars{
//		BackgroundImg: imgUrl,
//		Title:         sectionName,
//		CreateTime:    createTimeStr,
//	}
//	parsByte, e := json.Marshal(pars)
//	if e != nil {
//		response.Fail("分享图参数有误", c)
//		return
//	}
//	shareImg, e := services.GetDynamicShareImg(services.VoiceBroadcastShareImgSource, string(parsByte))
//	if e != nil {
//		response.Fail("生成分享图失败", c)
//		return
//	}
//
//	ext := path.Ext(file.Filename)
//	if ext != ".mp3" {
//		response.Fail("暂仅支持mp3格式", c)
//		return
//	}
//	dateDir := time.Now().Format("20060102")
//	localDir := global.CONFIG.Serve.StaticDir + "hongze/" + dateDir
//	if err := os.MkdirAll(localDir, 0766); err != nil {
//		response.FailMsg("存储目录创建失败", "QuestionUploadAudio 存储目录创建失败, Err:"+err.Error(), c)
//		return
//	}
//	randStr := utils.GetRandStringNoSpecialChar(28)
//	filtName := randStr + ext
//	fpath := localDir + "/" + filtName
//	defer func() {
//		_ = os.Remove(fpath)
//	}()
//	// 生成文件至指定目录
//	if err := c.SaveUploadedFile(file, fpath); err != nil {
//		response.FailMsg("文件生成失败", "QuestionUploadAudio 文件生成失败, Err:"+err.Error(), c)
//		return
//	}
//	// 获取音频文件时长
//	fByte, err := ioutil.ReadFile(fpath)
//	if err != nil {
//		response.FailMsg("读取本地文件失败", "QuestionUploadAudio 读取本地文件失败", c)
//		return
//	}
//	if len(fByte) <= 0 {
//		response.FailMsg("文件大小有误", "QuestionUploadAudio 文件大小有误", c)
//		return
//	}
//	seconds, err := services.GetMP3PlayDuration(fByte)
//	if err != nil {
//		response.FailMsg("读取文件时长失败", "QuestionUploadAudio 读取文件时长失败", c)
//		return
//	}
//	// 音频大小MB
//	fi, err := os.Stat(fpath)
//	if err != nil {
//		response.FailMsg("读取文件大小失败", "QuestionUploadAudio 读取文件大小失败", c)
//		return
//	}
//	mb := utils.Bit2MB(fi.Size(), 2)
//	// 上传文件至阿里云
//	ossDir := "yb_wx/voice_broadcast/"
//	resourceUrl, err := services.UploadAliyunToDir(filtName, fpath, ossDir)
//	if err != nil {
//		response.FailMsg("文件上传失败", "QuestionUploadAudio 文件上传失败, Err:"+err.Error(), c)
//		return
//	}
//
//	voiceBroadcast := voice_broadcast.VoiceBroadcast{
//		BroadcastName:    broadcastName,
//		SectionId:        sectionId,
//		SectionName:      sectionName,
//		VarietyId:        varietyId,
//		VarietyName:      varietyName,
//		AuthorId:         authorId,
//		Author:           author,
//		ImgUrl:           shareImg,
//		VoiceUrl:         resourceUrl,
//		VoicePlaySeconds: fmt.Sprint(seconds),
//		VoiceSize:        fmt.Sprint(mb),
//		CreateTime:       time.Now().Format(utils.FormatDateTime),
//	}
//	err = voiceBroadcast.AddVoiceBroadcast()
//	if err != nil {
//		fmt.Println("AddUserViewHistory err", err.Error())
//	}
//	response.OkData("发布成功", voiceBroadcast.BroadcastId, c)
//}

// PublishBroadcast
// @Description 发布语音播报
// @Param broadcast_id		query  int  	false  	"语音播报ID"
// @Param broadcast_name	query  string  	true  	"语音标题"
// @Param section_id		query  int  	true  	"板块ID"
// @Param section_name		query  string  	true  	"板块名称"
// @Param variety_id		query  int		true  	"品种ID"
// @Param variety_name		query  string	true  	"品种名称"
// @Param author_id			query  int		true  	"作者ID"
// @Param author			query  string  	true  	"作者名称"
// @Param img_url			query  string  	true  	"分享图背景"
// @Param Imgs				query  string  	true  	"图片,英文逗号拼接"
// @Param publish_type		query  string  	true  	"发布类型: 0-仅发布 1-发布并推送 2-定时发布"
// @Param pre_publish_time	query  string  	false	"预发布时间"
// @Param file				query  string  	true	"音频文件"
// @Success 200 {string} string "发布成功"
// @failure 400 {string} string "发布失败"
// @Router /add [post]
func PublishBroadcast(c *gin.Context) {
	var req request.SaveBroadcastReq
	if err := c.Bind(&req); err != nil {
		response.Fail("参数有误", c)
		return
	}
	// 参数校验
	if req.BroadcastName == "" {
		response.Fail("请输入标题", c)
		return
	}
	if req.SectionId <= 0 || req.SectionName == "" {
		response.Fail("请选择品种", c)
		return
	}
	if req.SectionId <= 0 || req.SectionName == "" {
		response.Fail("请选择板块", c)
		return
	}
	if req.File == nil {
		response.Fail("请上传音频", c)
		return
	}
	if req.ImgUrl == "" {
		response.Fail("分享图背景不能为空", c)
		return
	}
	if req.PublishType == 2 && req.PrePublishTime == "" {
		response.Fail("定时发布请选择发布时间", c)
		return
	}
	if req.Imgs != "" {
		imgList := strings.Split(req.Imgs, ",")
		if len(imgList) > 5 {
			response.Fail("最多插入五张图片", c)
			return
		}
	}
	// 发布语音
	if msg, e := services.PublishVoiceBroadcast(req.BroadcastId, req.SectionId, req.VarietyId, req.AuthorId, req.PublishType, req.BroadcastName,
		req.SectionName, req.VarietyName, req.Author, req.ImgUrl, req.PrePublishTime, req.Imgs, req.File); e != nil {
		response.FailMsg(msg, e.Error(), c)
		return
	}
	response.Ok("发布成功", c)
}

// SectionList
// @Description 语音播报板块列表
// @Success 200 {object} []voiceResp.VarietyList
// @failure 400 {string} string "获取失败"
// @Router /section/list [get]
func SectionList(c *gin.Context) {
	sList, err := voice_section.GetVoiceSection()
	if err != nil {
		response.FailMsg("查询语音播报板块失败", "GetVoiceSection, Err:"+err.Error(), c)
	}
	vList, err := voice_section.GetVoiceVariety()
	if err != nil {
		response.FailMsg("查询语音播报板块失败", "GetVoiceSection, Err:"+err.Error(), c)
	}
	var sectionList []voiceResp.SectionList
	var varietyList []voiceResp.VarietyList
	var resp []voiceResp.VarietyList
	//var resp voiceResp.SectionListResp
	//for _, s := range sList {
	//	section := voiceResp.SectionList{
	//		SectionId:   s.SectionId,
	//		SectionName: s.SectionName,
	//		Status:      s.Status,
	//	}
	//	sectionList = append(sectionList, section)
	//}
	var newsList []*voice_section.VoiceSection
	//var bannedSectionList []*voice_section.VoiceSection

	//查找被禁用的板块ids
	var bannedIds []int
	for _, section := range sList {
		if section.Status == 0 {
			//bannedSectionList = append(bannedSectionList, section)
			bannedIds = append(bannedIds, section.SectionId)
		} else {
			newsList = append(newsList, section)
		}
	}

	//如果有被禁用的板块，去语音列表查找被禁用板块有没有语音
	var lists []*voice_broadcast.VoiceBroadcast
	if len(bannedIds) > 0 {
		lists, err = voice_section.GetVoiceSectionFromBroadcast(bannedIds)
		if err != nil {
			response.FailMsg("查询语音播报禁用板块失败", "GetVoiceSectionFromBroadcast, Err:"+err.Error(), c)
		}
	}

	//被禁用板块有语音，依然显示该板块
	if len(lists) > 0 {
		//清空切片,用新的
		newsList = newsList[0:0]
		bannedMap := make(map[int]int)
		for _, broadcast := range lists {
			bannedMap[broadcast.SectionId] = broadcast.SectionId
		}
		for _, section := range sList {
			_, ok := bannedMap[section.SectionId]
			if section.Status != 0 || ok {
				newsList = append(newsList, section)
			}
		}
	}

	for _, v := range vList {
		variety := voiceResp.VarietyList{
			VarietyId:   v.VarietyId,
			VarietyName: v.VarietyName,
		}
		varietyList = append(varietyList, variety)
	}

	for _, v := range varietyList {
		for _, s := range newsList {
			if v.VarietyId == s.VarietyId {
				section := voiceResp.SectionList{
					ImgUrl:      s.ImgUrl,
					SectionId:   s.SectionId,
					SectionName: s.SectionName,
					Status:      s.Status,
				}
				sectionList = append(sectionList, section)
			}
		}
		if len(sectionList) == 0 {
			continue
		}
		v.Children = sectionList
		resp = append(resp, v)
		sectionList = []voiceResp.SectionList{}
	}
	response.OkData("上传成功", resp, c)
}

// DelBroadcast
// @Description 删除语音播报
// @Param broadcast_id			query int false "语音播报id"
// @Success 200 {string} string "删除成功"
// @failure 400 {string} string "删除失败"
// @Router /delete [get]
func DelBroadcast(c *gin.Context) {
	sbroadcastId := c.DefaultQuery("broadcast_id", "0")
	broadcastId, err := strconv.Atoi(sbroadcastId)
	if err != nil {
		response.FailMsg("转换id失败，请输入正确的id", "strconv.Atoi, Err:"+err.Error(), c)
	}
	if broadcastId <= 0 {
		response.FailMsg("参数错误", "参数有误", c)
		return
	}
	var item voice_broadcast.VoiceBroadcast
	item.BroadcastId = broadcastId
	err = item.DelVoiceBroadcast()
	if err != nil {
		response.FailMsg("删除语音播报失败", "DelVoiceBroadcast, Err:"+err.Error(), c)
	}
	response.Ok("删除成功", c)
}

// AddStatistics
// @Description 新增语音播报记录
// @Param file  query  string  true  "音频文件"
// @Success 200 {string} string "新增成功"
// @failure 400 {string} string "新增失败"
// @Router /statistics/add [post]
func AddStatistics(c *gin.Context) {
	var req request.AddBroadcastStatisticsReq
	if err := c.Bind(&req); err != nil {
		response.Fail("参数有误", c)
		return
	}

	if req.BroadcastId <= 0 {
		response.Fail("参数有误", c)
	}
	userinfo := user.GetInfoByClaims(c)

	go services.AddBroadcastRecord(userinfo, req.Source, req.BroadcastId)

	response.Ok("新增记录成功", c)
}

// BroadcastDetail 获取语音播报详情
// @Tags 语音播报模块
// @Description 获取语音播报详情
// @Param variety_tag_id  query  int  true  "标签ID"
// @Success 200 {object} response.PriceDrivenItem
// @failure 400 {string} string "获取失败"
// @Router /detail [get]
func BroadcastDetail(c *gin.Context) {
	var req request.BroadcastDetailReq
	if err := c.Bind(&req); err != nil {
		response.Fail("参数有误", c)
		return
	}
	if req.BroadcastId <= 0 {
		response.Fail("参数有误", c)
		return
	}
	userInfo := user.GetInfoByClaims(c)
	item, e := voice_broadcast.GetBroadcastById(req.BroadcastId)
	if e != nil {
		response.FailMsg("获取失败", "BroadcastDetail ErrMsg:"+e.Error(), c)
		return
	}
	resp := &voiceResp.Broadcast{
		BroadcastId:      item.BroadcastId,
		BroadcastName:    item.BroadcastName,
		SectionId:        item.SectionId,
		SectionName:      item.SectionName,
		VarietyId:        item.VarietyId,
		VarietyName:      item.VarietyName,
		AuthorId:         item.AuthorId,
		Author:           item.Author,
		ImgUrl:           item.ImgUrl,
		VoiceUrl:         item.VoiceUrl,
		VoicePlaySeconds: item.VoicePlaySeconds,
		VoiceSize:        item.VoiceSize,
		CreateTime:       item.CreateTime,
	}
	// 是否为作者、是否可以推送消息
	if int(userInfo.UserID) == item.AuthorId {
		resp.IsAuthor = true
		if item.MsgState == 0 {
			resp.CouldSendMsg = true
		}
	}
	response.OkData("获取成功", resp, c)
}

// MsgSend 语音播报消息推送
// @Tags 语音播报模块
// @Description 语音播报消息推送
// @Param broadcast_id	query  int  true  "语音播报ID"
// @Success 200 {string} string "操作成功"
// @failure 400 {string} string "操作失败"
// @Router /msg_send [post]
func MsgSend(c *gin.Context) {
	var req request.BroadcastMsgSendReq
	if err := c.Bind(&req); err != nil {
		response.Fail("参数有误", c)
		return
	}
	if req.BroadcastId <= 0 {
		response.Fail("参数有误", c)
		return
	}
	userInfo := user.GetInfoByClaims(c)
	errMsg, err := services.SendBroadcastMsg(req.BroadcastId, int(userInfo.UserID))
	if err != nil {
		response.FailMsg(errMsg, "MsgSend ErrMsg:"+err.Error(), c)
		return
	}
	response.Ok("操作成功", c)
}