package dao

import (
	"encoding/json"
	"errors"

	"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
}

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 GetArtworkList(req *artwork.GetArtworkListRequest) (rep *artwork.GetArtworkListRespond, err error) {
	rep = &artwork.GetArtworkListRespond{}
	var datas []*artwork.UpdateArtworkRequest

	var artworkList []model.Artwork
	//找到用户
	if err = db.DB.Order("created_at desc").Where("artist_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.First(&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(err))
		err = errors.New(m.SAVE_ERROR)
		return
	}
	return
}