package dao

import (
	"encoding/json"
	"errors"

	"github.com/alibaba/sentinel-golang/logging"
	"github.com/fonchain-artistserver/cmd/model"
	"github.com/fonchain-artistserver/pb/artwork"
	db "github.com/fonchain-artistserver/pkg/db"
	"github.com/fonchain-artistserver/pkg/m"
	"go.uber.org/zap"
)

func ArtworkAdd(res *artwork.ArtworkAddRequest) (req *artwork.ArtworkAddRespond, err error) {
	CreataAddByte, err := json.Marshal(res.CreateAddress)
	if err != nil {
		zap.L().Error("marshal createAddress failed", zap.Error(err))
		err = errors.New(m.ERROR_MARSHAL)
		return
	}
	artwork := &model.Artwork{
		ArtistId:      int32(res.ArtistId),
		Name:          res.Name,
		ModelYear:     res.ModelYear,
		Photo:         res.Photo,
		ArtistPhoto:   res.ArtistPhoto,
		CreateAddress: string(CreataAddByte),
		Width:         int32(res.Width),
		AgeOfCreation: res.AgeOfCreation,
		Height:        int32(res.Height),
		Ruler:         int32(res.Ruler),
		Introduct:     res.Introduct,
		NetworkTrace:  res.NetworkTrace,
		Url:           res.Url,
		State:         int32(res.State),
	}

	if err = db.DB.Create(&artwork).Error; err != nil {
		zap.L().Error("create artwork info err", zap.Error(err))
		err = errors.New(m.CREATE_ERROR)
		return
	}

	return
}


	
//Get 用户修改信息
func (service UserUpdateInfoService) Update(id uint) serializer.Response {
	var user model.User
	code := e.SUCCESS
	//找到用户
	err := model.DB.First(&user, "id = ?", id).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: 400,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	user.PenName = service.PenName
	user.Photo = service.Photo
	user.Video = service.Video
	user.CertificateImg = service.CertificateImg
	conAddessByte, err := json.Marshal(service.ConAddress)
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: 400,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	user.ConAddress = string(conAddessByte)
	user.WxAccount = service.WxAccount
	user.CertificateNum = service.CertificateNum
	err = model.DB.Save(&user).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: 400,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	var realName model.RealName
	err = model.DB.First(&realName, "id = ?", user.RealNameID).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: 400,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	realName.IdcardBack = service.IdCardBack
	realName.IdcardFront = service.IdCardFront
	err = model.DB.Save(&realName).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: 400,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	return serializer.Response{
		Status: code,
		Data:   serializer.BuildUser(user),
		Msg:    e.GetMsg(code),
	}
}






func CheckUserLock(id int64) (err error) {
	var user model.User
	if err = db.DB.Where("id = ? ", id).First(&user).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	if user.IsLock {
		zap.L().Error("user is lock")
		return errors.New(m.ERROR_ISLOCK)
	}

	return
}

func UpdateArtwork(data *artwork.UpdateArtworkRequest) (err error) {
	var artwork model.Artwork
	artwork.ID = int32(data.ID)
	if err = db.DB.First(&artwork).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	CreataAddByte, _ := json.Marshal(data.CreateAddress)
	artwork.ID = int32(data.ID)
	artwork.ArtistId = int32(data.ArtistId)
	artwork.Name = data.Name
	artwork.ModelYear = data.ModelYear
	artwork.Photo = data.Photo
	artwork.ArtistPhoto = data.ArtistPhoto
	artwork.Width = int32(data.Width)
	artwork.AgeOfCreation = data.AgeOfCreation
	artwork.CreateAddress = string(CreataAddByte)
	artwork.Height = int32(data.Height)
	artwork.Ruler = int32(data.Ruler)
	artwork.Introduct = data.Introduct
	artwork.NetworkTrace = data.NetworkTrace
	artwork.Url = data.Url
	artwork.State = 1

	if err = db.DB.Save(&artwork).Error; err != nil {
		zap.L().Error("save artwork info err", zap.Error(err))
		err = errors.New(m.SAVE_ERROR)
		return
	}

	return
}

func DelArtwork(id int32) (err error) {
	if err = db.DB.Where("id = ?", id).Delete(&model.Artwork{}).Error; err != nil {
		zap.L().Error("delete artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_DELETE)
		return
	}

	return
}
func ApproveArtwork(req *artwork.ApproveArtworkRequest)(rep *artwork.ApproveArtworkRespond,err error){

	var artwork model.Artwork
	artwork.ID = int32(data.ID)
	var state int
	if req.IsApprove {
		state = 3
	} else {
		state = 4
	}
	if err = db.DB.Update(&artwork).Where("state = ?,remark = ?,remark2 = ?",state,req.Remark,req.Remark2).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}
func GetArtworkList(req *artwork.GetArtworkListRequest) (rep *artwork.GetArtworkListRespond, err error) {
	rep = &artwork.GetArtworkListRespond{}
	var datas []*artwork.UpdateArtworkRequest

	var artworkList []model.Artwork
	//找到用户  p[]
	if err = db.DB.Order("created_at desc").Where("id = ?", req.Id).Find(&artworkList).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	for k, v := range artworkList {
		artworkList[k].CreateTime = v.CreatedAt.Format("2006-01-02")
		var data artwork.UpdateArtworkRequest
		var createAddressByte []string
		json.Unmarshal([]byte(artworkList[k].CreateAddress), &createAddressByte)
		data.ID = uint64(artworkList[k].ID)
		// data.ArtistId = uint64(artworkList[k].ArtistId)
		data.Name = artworkList[k].Name
		data.ModelYear = artworkList[k].ModelYear
		data.Photo = artworkList[k].Photo
		data.ArtistPhoto = artworkList[k].ArtistPhoto
		data.Width = uint64(artworkList[k].Width)
		data.CreateAddress = createAddressByte
		data.Height = uint64(artworkList[k].Height)
		data.Ruler = uint64(artworkList[k].Ruler)
		data.Introduct = artworkList[k].Introduct
		data.AgeOfCreation = artworkList[k].AgeOfCreation
		data.CreateAt = artworkList[k].CreateTime
		data.NetworkTrace = artworkList[k].NetworkTrace
		data.Url = artworkList[k].Url
		data.State = uint64(artworkList[k].State)
		datas = append(datas, &data)
	}
	rep.Data = datas
	return
}

func GetArtwork(id int32) (rep *artwork.GetArtworkRespond, err error) {
	rep = &artwork.GetArtworkRespond{}

	var artworkRes model.Artwork
	if err = db.DB.Find(&artworkRes, "id = ? and deleted_at is null", id).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	artworkRes.CreateTime = artworkRes.CreatedAt.Format("2006-01-02")
	var createAddressByte []string
	json.Unmarshal([]byte(artworkRes.CreateAddress), &createAddressByte)
	rep.ID = uint64(artworkRes.ID)
	// rep.ArtistId = uint64(artworkRes.ArtistId)
	rep.Name = artworkRes.Name
	rep.ModelYear = artworkRes.ModelYear
	rep.Photo = artworkRes.Photo
	rep.ArtistPhoto = artworkRes.ArtistPhoto
	rep.Width = uint64(artworkRes.Width)
	rep.CreateAddress = createAddressByte
	rep.Height = uint64(artworkRes.Height)
	rep.Ruler = uint64(artworkRes.Ruler)
	rep.Introduct = artworkRes.Introduct
	rep.AgeOfCreation = artworkRes.AgeOfCreation
	rep.CreateAt = artworkRes.CreateTime
	rep.NetworkTrace = artworkRes.NetworkTrace
	rep.Url = artworkRes.Url
	rep.State = uint64(artworkRes.State)
	return
}

func UploadArtwork(Id uint64) (err error) {
	var artwork model.Artwork
	if err = db.DB.Find(&artwork, "id = ?", Id).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	artwork.State = 1

	if err = db.DB.Save(&artwork).Error; err != nil {
		zap.L().Error("save artwork info err", zap.Error(rr))
		err = errors.New(m.SAVE_ERROR)
		return
	}
	return
}

func GetMgmtArtworkList(req *artwork.GetMgmtArtworkListRequest) (rep *artwork.GetMgmtArtworkListRespond, err error) {
	rep = &artwork.GetArtworkListRespond{}
	var datas []*artwork.UpdateArtworkRequest
	id, err := GetUserId(req.ArtistId)
	if err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	var args []interface{}
	var sqlWhere = " (state >=1 and state <=3) "
	if req.Name != "" {
		sqlWhere += ` and name like ? `
		args = append(args, "%"+req.Name+"%")
	}
	// if req.BatchId != 0 {
	// 	sqlWhere += `and c.batch_id = ? `
	// 	args = append(args, req.BatchId)
	// }
	if req.ArtistId != 0 {
		sqlWhere += `  artist_id = ? `
		args = append(args, id)
	}
	if req.State != 0 {
		sqlWhere += ` and state = ? `
		args = append(args, req.State)
	}
	//找到用户
	var artworkCount model.Artwork

	tx = db.DB.Where(sqlWhere, args...).Count(&artworkCount)
	if tx.Error != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	rep.Count = tx.
	var artworkList []model.Artwork
	//找到用户
	var sqlLimit = sqlWhere + " limit ?,? "
	args = append(args, (req.Page-1)*req.PageSize)
	args = append(args, req.Num)
	if err = db.DB.Order("created_at desc").Where(sqlWhere, args...).Find(&artworkList).Error; err != nil {
		zap.L().Error("get artwork info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	for k, v := range artworkList {
		artworkList[k].CreateTime = v.CreatedAt.Format("2006-01-02")
		var data artwork.UpdateArtworkRequest
		var createAddressByte []string
		json.Unmarshal([]byte(artworkList[k].CreateAddress), &createAddressByte)
		data.Name = artworkList[k].Name
		data.ModelYear = artworkList[k].ModelYear
		data.Photo = artworkList[k].Photo
		data.ArtistPhoto = artworkList[k].ArtistPhoto
		data.CreateAt = artworkList[k].CreateTme
		data.NetworkTrace = artworkList[k].Netor
		data.Url = artworkList[k].Url
		data.State = uint64(artworkList[k].State)
		datas = append(datas, &data)
	}
	rep.Data = datas
	return
}

func GetUserId(artistId string) (uint64, error) {
	var user model.User
	if err := db.DB.First(&user, "id = ? and deleted_at is null", id).Error; err != nil {

	
		err = errors.New(m.ERROR_SELECT)
		return 0, err
	}
	return user.ID, nil

}