// Package dao -----------------------------
// @file      : artwork.go
// @author    : JJXu
// @contact   : wavingbear@163.com
// @time      : 2023/2/24 18:23
// -------------------------------------------
package dao

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/artistInfoArtwork"
	"github.com/fonchain/fonchain-artistinfo/pb/artwork_query"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"github.com/fonchain/fonchain-artistinfo/pkg/service"
	"github.com/fonchain/fonchain-artistinfo/pkg/util/stime"
	"gorm.io/gorm"
)

func CreateArtworkLockRecord(in *model.ArtworkLockRecord) error {
	var data = model.ArtworkLockRecord{
		ArtistUid:  in.ArtistUid,
		ArtworkUid: in.ArtworkUid,
		Status:     in.Status,
		LockTime:   in.LockTime,
	}
	return db.DB.Create(&data).Error
}

func UpdateArtworkLockRecord(in *model.ArtworkLockRecord) error {
	var data = model.ArtworkLockRecord{
		ArtistUid:             in.ArtistUid,
		ArtworkUid:            in.ArtworkUid,
		Status:                in.Status,
		LockTime:              in.LockTime,
		BaseAuditStatus:       in.BaseAuditStatus,
		BaseAuditMark:         in.BaseAuditMark,
		BaseAuditMark2:        in.BaseAuditMark2,
		SupplementAuditStatus: in.SupplementAuditStatus,
		SupplementAuditMark:   in.SupplementAuditMark,
		SupplementAuditMark2:  in.SupplementAuditMark2,
	}
	var thisData model.ArtworkLockRecord
	err := db.DB.Where("artist_uid = ?", in.ArtworkUid).First(&thisData).Error
	if err != nil {
		if err != gorm.ErrRecordNotFound {
			return errors.New("画作数据未找到")
		} else {
			return err
		}
	}
	data.Model = model.Model{
		ID:        thisData.ID,
		CreatedAt: thisData.CreatedAt,
	}
	return db.DB.Updates(&data).Error
}

func DeletedArtworkLockRecord(artworkUid ...string) error {
	if len(artworkUid) == 0 {
		return nil
	} else if len(artworkUid) == 1 {
		return db.DB.Where("artwork_uid = ? AND status != 2 ", artworkUid[0]).Delete(&model.ArtworkLockRecord{}).Error
	} else {
		return db.DB.Where("artwork_uid in ? AND status != 2 ", artworkUid).Delete(&model.ArtworkLockRecord{}).Error
	}
}

func BatchLockArtworks(artistUid string, lockTime string) error {
	var artworkUids []string
	db.DB.Model(model.ArtworkLockRecord{}).
		Where("status = 1 AND lock_time=''").Where(" artist_uid = ?", artistUid).
		Pluck("artwork_uid", &artworkUids)
	if artworkUids == nil {
		return nil
	}
	if lockTime == "" {
		lockTime = stime.TimeToString(time.Now(), stime.Format_Normal_YMDhms)
	}
	var updateMap = map[string]any{
		"status":            2,
		"lock_time":         lockTime,
		"base_audit_status": model.AuditType_Pending, //基本数据审批
		"audit_flow_index":  2,                       //进入基本信息审批流程
	}
	return db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid in ?", artworkUids).Updates(&updateMap).Error
}

func BatchUnlockArtworks(artistUid string) error {
	//var artworkUids []string
	// 查询用户当前锁定的时间点
	//var nowLockTime string
	//err := db.DB.Model(model.ArtworkLockRecord{}).Select("MAX(lock_time)").Where("artist_uid = %s AND lock_time !='' AND STATUS =2", artistUid).Scan(&nowLockTime).Error
	//if err != nil {
	//	return err
	//}
	////查询此时间节点内的所有画作
	//db.DB.Model(model.ArtworkLockRecord{}).
	//	//Where("lock_time = (SELECT MAX(lock_time) FROM artwork_lock_record where artist_uid = %s AND lock_time !='' AND STATUS =2)", artistUid).
	//	//Joins("LEFT JOIN (lock_time = (select max(lock_time) form artwork_lock_record WHERE artist_uid = ?) lt", artistUid).
	//	//Where(fmt.Sprintf("lock_time = (select max(lock_time) form artwork_lock_record WHERE artist_uid = %s)", artistUid)).
	//	Where("status = 2").
	//	Pluck("artwork_uid", &artworkUids)
	//if artworkUids == nil {
	//	return nil
	//}
	return db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ? AND status =2 AND lock_time !=''", artistUid).Update("status", 3).Error
}

func GetArtworkLockDetail(artworkUid string) (data model.ArtworkLockRecord, err error) {
	err = db.DB.Where("artwork_uid = ?", artworkUid).First(&data).Error
	return
}

func GetArtworkLockRecords(req *artistInfoArtwork.GetArtworkLockRecordsRequest) (resp *artistInfoArtwork.ArtworkLockList, err error) {
	var (
		datas = []model.ArtworkLockRecord{}
		tx    = db.DB.Model(model.ArtworkLockRecord{}).Order("lock_time desc")
	)
	if req.Page == 0 || req.PageSize == 0 {
		req.Page = 1
		req.PageSize = -1
	}
	resp = &artistInfoArtwork.ArtworkLockList{}
	if req.ArtistUid != "" {
		tx = tx.Where("artist_uid = ?", req.ArtistUid)
	}
	switch req.QueryType {
	case artistInfoArtwork.ArtworkQueryMode_NowPreSaveArtwork: //当前暂存的画作
		tx = tx.Where("status = 1")
	case artistInfoArtwork.ArtworkQueryMode_NowLockedArtwork: //当前已锁定的画作
		tx = tx.Where("status = 2")
	case artistInfoArtwork.ArtworkQueryMode_NowPreSaveAndLocked: //当前暂存和已锁定的画作（也就是用户端画作管理中的数据）
		tx = tx.Where("status =1 OR status =2")
	case artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfBase: //当前处于基本信息审批阶段的画作(包括进入其它流程的画作)
		tx = tx.Where("status = 2 ") // AND audit_flow_index = 2
	case artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing: //当前处于补充信息审批阶段的画作
		tx = tx.Where("status =2 AND audit_flow_index = 3")
	case artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork: //所有已解锁的画作(历史画作)
		tx = tx.Where("status = 3").Order("lock_time desc")
		//case artistInfoArtwork.ArtworkQueryMode_AllHistoryArtwork: //所有历史画作
		//	tx = tx.Where("status > 1")
	case artistInfoArtwork.ArtworkQueryMode_AllAuditPassArtwork: //所有审核通过的画作
		tx = tx.Where("supplement_audit_status = 4").Order("lock_time desc")
	}
	if req.BaseAuditStatus != 0 {
		tx = tx.Where("base_audit_status = ?", req.BaseAuditStatus)
	}
	if req.SupplementAuditStatus != 0 {
		tx = tx.Where("supplement_audit_status = ?", req.SupplementAuditStatus)
	}
	if len(req.ArtworkUids) > 0 {
		tx = tx.Where("artwork_uid in ?", req.ArtworkUids)
	}
	err = tx.Count(&resp.Total).Scopes(db.Pagination(req.Page, req.PageSize)).Find(&datas).Error
	for _, v := range datas {
		resp.Data = append(resp.Data, &artistInfoArtwork.ArtistLockInfo{
			ArtistUid:             v.ArtistUid,
			ArtworkUid:            v.ArtworkUid,
			Status:                v.Status,
			LockTime:              v.LockTime,
			BaseAuditStatus:       int32(v.BaseAuditStatus),
			BaseAuditMark:         v.BaseAuditMark,
			BaseAuditMark2:        v.BaseAuditMark2,
			SupplementAuditStatus: int32(v.SupplementAuditStatus),
			SupplementAuditMark:   v.SupplementAuditMark,
			SupplementAuditMark2:  v.SupplementAuditMark2,
			AuditFlowIndex:        int32(v.AuditFlowIndex),
			CreatedAt:             v.CreatedAt.Unix(),
			UpdatedAt:             v.UpdatedAt.Unix(),
			DeletedAt:             int64(v.DeletedAt),
		})
	}

	resp.Page = req.Page
	if req.PageSize == -1 {
		resp.PageSize = int64(len(datas))
	} else {
		resp.PageSize = req.PageSize
	}
	return
}
func HasBeenLocked(artistUid string) bool {
	//检查是否已经被锁定
	var hasLocked int64
	db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ? AND status = 2", artistUid).Count(&hasLocked)
	if hasLocked > 0 {
		return true
	}
	return false
}

// UpdateAuditStatus 更新审批状态
// flowIndex 2=基本信息审批 3=补充信息审批
func UpdateAuditStatus(artworkUid string, auditStatus int64, remark1 string, remark2 string, flowIndex int64) error {
	var thisData model.ArtworkLockRecord
	err := db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid = ?", artworkUid).First(&thisData).Error
	if err != nil {
		if err != gorm.ErrRecordNotFound {
			return errors.New("画作数据未找到")
		} else {
			return err
		}
	}
	switch flowIndex {
	case 2:
		thisData.BaseAuditStatus = model.AuditStatus(auditStatus)
		thisData.BaseAuditMark = remark1
		thisData.BaseAuditMark2 = remark2
	case 3:
		thisData.SupplementAuditStatus = model.AuditStatus(auditStatus)
		thisData.SupplementAuditMark = remark1
		thisData.SupplementAuditMark2 = remark2
	}
	return db.DB.Save(&thisData).Error
}

func BatchUpdateAuditStatus(artworkUids []string, auditStatus int64, remark1 string, remark2 string, flowIndex int64) error {
	for _, uid := range artworkUids {
		if err := UpdateAuditStatus(uid, auditStatus, remark1, remark2, flowIndex); err != nil {
			return err
		}
	}
	return nil
}

func GenerateArtworkSupplementInfo(artworkUids []string) error {
	var datas = []model.ArtworkLockRecord{}
	db.DB.Where("artwork_uid in ?", artworkUids).Find(&datas)
	for _, v := range datas {
		if v.BaseAuditStatus != 4 {
			return errors.New("存在基本信息未审批通过的画作,操作取消!")
		}
	}
	var updateData = map[string]any{
		"audit_flow_index":        3,
		"supplement_audit_status": 5,
	}
	return db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid in ?", artworkUids).Updates(&updateData).Error
}

func PassedArtworkStatic(request *artistInfoArtwork.ArtistArtworkStaticRequest, uids []string) (res []model.ViewPassedArtworkStatic, err error) {
	res = []model.ViewPassedArtworkStatic{}
	var tx = db.DB.Model(&model.ViewPassedArtworkStatic{})
	err = tx.Where("artist_uid in ?", uids).Scopes(db.Pagination(request.Page, request.PageSize)).Find(&res).Error
	return
}

// CountArtworkTotalWhichAuditPassed 单个统计画家已通过的画作数量和已通过的平尺数
func CountArtworkTotalWhichAuditPassed(artistUid string) (rulerPassedTotal int64, artworkPassedCount int64) {
	artworkList, err := GetArtworkLockRecords(&artistInfoArtwork.GetArtworkLockRecordsRequest{
		ArtistUid: artistUid,
		QueryType: artistInfoArtwork.ArtworkQueryMode_AllAuditPassArtwork,
	})
	if err != nil {
		fmt.Println("service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error:", err.Error())
		return 0, 0
	}
	if len(artworkList.Data) == 0 {
		fmt.Println("service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords :画作数量为0")
		return 0, 0
	}
	var artworkUids = []string{}
	for _, v := range artworkList.Data {
		artworkUids = append(artworkUids, v.ArtworkUid)
	}
	//搜索画作信息
	var (
		defultPageSize    int32 = 500
		nowPageIndex      int32
		artworkNumber     int32
		artworkRulerTotal int32
		artworkTotal      int32
	)
	for {
		nowPageIndex++
		res, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
			Page:        nowPageIndex,
			PageSize:    defultPageSize,
			ArtistUid:   artistUid,
			ArtworkUids: artworkUids,
		})
		if err != nil {
			fmt.Println(err.Error())
			return 0, 0
		}
		if artworkNumber == 0 {
			artworkNumber = res.Page.Total
			artworkTotal += res.Page.Total
		}
		artworkNumber -= defultPageSize
		for _, v := range res.Data {
			artworkRulerTotal += v.Ruler
		}
		if artworkNumber <= 0 {
			break
		}
	}
	return int64(artworkRulerTotal), int64(artworkTotal)
}

// CountAllArtworkTotal 单个统计画家所有的画作数量和平尺数
func CountAllArtworkTotal(artistUid string) (artworkTotal int64, artworkRulerTotal int64) {
	//查询画家宝中的画作总数
	var artworkUids []string
	db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ?", artistUid).Pluck("artwork_uid", &artworkUids)
	artworkTotal = int64(len(artworkUids))
	//查询此画家的所有画作
	artworkList, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
		Page:        1,
		PageSize:    -1,
		ArtistUid:   artistUid,
		ArtworkUids: artworkUids,
	})
	if err != nil {
		fmt.Println("画作列表查询失败", err.Error())
		return 0, 0
	}
	for _, v := range artworkList.Data {
		artworkRulerTotal += int64(v.Ruler)
	}
	return artworkTotal, artworkRulerTotal
}