package controller

import (
	"BlogAdmin/third_party/SessionUtil"
	"BlogAdmin/third_party/database"
	"Common/consts"
	"Common/model/AjaxResult"
	"Common/model/admin"
	"Common/model/vo"
	"bytes"
	"context"
	"image/jpeg"
	"log"
	"mime/multipart"
	"strings"
	"time"

	"github.com/google/uuid"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/sessions"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

/*
日记管理
*/
type DiaryController struct {
	Ctx     iris.Context
	Session *sessions.Session
}

func (ctrl *DiaryController) Get() {
	ctrl.Ctx.View("/admin/diary/index.html")
}

func (ctrl *DiaryController) PostSubmit() {
	user := SessionUtil.GetUser(ctrl.Session)
	createBy := user.Username

	content := ctrl.Ctx.FormValue("content")
	var err error

	ctx := context.Background()

	diaryId := uuid.NewString()
	database.WGorm(func(tx *gorm.DB) error {
		now := time.Now().UnixMilli()
		diary := admin.AdminDiary{Id: diaryId, PublishTime: now, Del: 0, CreateTime: now, CreateBy: createBy}
		ctn := vo.CommonContent{Id: uuid.NewString(), RelId: diaryId, Content: content, State: consts.CONTENT_STATE_PUBLISH}
		err = tx.Table("common_contents").Create(ctn).Error
		if err != nil {
			return err
		}
		files, headers, fileErr := ctrl.Ctx.FormFiles("file")
		if fileErr != nil {
			err = fileErr
			return fileErr
		}
		fileIds := []string{}
		for i := range files {
			// defer file.Close()
			header := headers[i]
			bytes := compressImg(header)
			fileSize := int64(len(bytes))
			// var bytes []byte = make([]byte, fileSize)
			// _, err = file.Read(bytes)
			// if err != nil {
			// 	return err
			// }
			fileName := header.Filename
			extLastIndex := strings.LastIndex(fileName, ".")
			ext := fileName[extLastIndex:]
			fileId := uuid.NewString()
			fileIds = append(fileIds, fileId+ext)
			sysFile := admin.SysFile{Id: fileId, FileName: fileName, FileSize: fileSize, Data: bytes, Sort: i, Del: 0, CreateBy: createBy, CreateTime: now}
			err = tx.Table("common_files").Create(&sysFile).Error
			if err != nil {
				return err
			}
		}

		if len(fileIds) > 0 {
			diary.Images = strings.Join(fileIds, ",")
		}

		err := tx.Table("blog_diaries").Create(&diary).Error
		if err != nil {
			return err
		}

		// database.GormTemplate.Table("blog_diaries").Where("id = ?", id).First(&diary)
		err = database.RedisTemplate.ZAdd(ctx, consts.REDIS_BLOG_DIARY_LATEST, redis.Z{Score: float64(diary.PublishTime), Member: &diary}).Err()
		if err != nil {
			return err
		}
		err = database.RedisTemplate.Set(ctx, consts.REDIS_BLOG_CONTENT+diaryId, content, time.Duration(0)).Err()
		return err
	})

	if err != nil {
		ctrl.Ctx.JSON(AjaxResult.OkMsg("发布成功", nil))
		return
	}
	ctrl.Ctx.JSON(AjaxResult.Error("发布失败"))
}

var compress int64 = 1 * 1024 * 1024

// 判断是否JPEG格式，按大小进行压缩
func compressImg(fileHeader *multipart.FileHeader) []byte {
	fileName := fileHeader.Filename
	fileSize := fileHeader.Size
	file, _ := fileHeader.Open()

	if strings.HasSuffix(fileName, "jpg") || strings.HasSuffix(fileName, "jpeg") {
		quality := 100
		if fileSize > compress {
			mul := fileSize / compress
			if mul > 1 {
				quality = 70
			}

			log.Println("JPG格式图片,判断是否压缩")
			i, err := jpeg.Decode(file)
			if err != nil {
				return nil
			}
			var buf []byte
			b := bytes.NewBuffer(buf)
			jpeg.Encode(b, i, &jpeg.Options{Quality: quality})
			return b.Bytes()
		}
	}

	var bytes []byte = make([]byte, fileSize)
	file.Read(bytes)
	return bytes
}