package dao

import (
	"errors"
	"fmt"

	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	statement "github.com/fonchain/fonchain-artistinfo/pb/artistinfoStatement"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

func IsExistArtworkTx(tx *gorm.DB, batchTime, artistUid string) (exist bool, artworkTx *model.ArtworkTx, err error) {

	if err = tx.Where("batch_time = ? AND  artist_uid = ?", batchTime, artistUid).First(&artworkTx).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return true, nil, nil
		} else {
			zap.L().Error("get artworkTx info err", zap.Error(err))
			err = errors.New(m.ERROR_SELECT)
			return
		}
	}

	return
}

func IsExistArtworkCopy(tx *gorm.DB, batchTime, artistUid string) (exist bool, artworkCopy *model.ArtworkCopy, err error) {

	if err = tx.Where("batch_time = ? AND  artist_uid = ?", batchTime, artistUid).First(&artworkCopy).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return true, nil, nil
		} else {
			zap.L().Error("get artworkCopy info err", zap.Error(err))
			err = errors.New(m.ERROR_SELECT)
			return
		}
	}

	return
}

func CreateArtworkTx(tx *gorm.DB, uid, batchTime, artistUid, artistName string) (err error) {
	artworkTx := &model.ArtworkTx{
		Uid:        uid,
		ArtistUid:  artistUid,
		ArtistName: artistName,
		BatchTime:  batchTime,
	}

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

	return
}

func CreateArtworkCopy(tx *gorm.DB, uid, batchTime, artistUid, artistName string) (err error) {
	artworkCopy := &model.ArtworkCopy{
		Uid:        uid,
		ArtistUid:  artistUid,
		ArtistName: artistName,
		BatchTime:  batchTime,
	}

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

	return
}

func CreateArtworkTxDetail(tx *gorm.DB, uid1, uid2 string, excelOneInfo *statement.ExcelOneInfo) (err error) {
	artworkTxDetail := &model.ArtworkTxDetail{
		Uid:            uid2,
		BatchUid:       uid1,
		TfNum:          excelOneInfo.TfNum,
		ArtworkName:    excelOneInfo.ArtworkName,
		Ruler:          excelOneInfo.Ruler,
		MinPrice:       excelOneInfo.MinPrice,
		GuaranteePrice: excelOneInfo.GuaranteePrice,
	}

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

	return
}

func CreateArtworkCopyDetail(tx *gorm.DB, uid1, uid2 string, excelOneInfo *statement.ExcelOneInfo) (err error) {
	artworkCopyDetail := &model.ArtworkCopyDetail{
		Uid:            uid2,
		BatchUid:       uid1,
		TfNum:          excelOneInfo.TfNum,
		ArtworkName:    excelOneInfo.ArtworkName,
		Ruler:          excelOneInfo.Ruler,
		MinPrice:       excelOneInfo.MinPrice,
		GuaranteePrice: excelOneInfo.GuaranteePrice,
	}

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

	return
}

func IsExistArtworkTxDetail(tx *gorm.DB, uid, tfNum string) (count int64, err error) {
	if err = tx.Model(&model.ArtworkTxDetail{}).Where("batch_uid = ? AND tf_num = ?", uid, tfNum).Count(&count).Error; err != nil {
		zap.L().Error("get artworkTxDetail num err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func IsExistArtworkCopyDetail(tx *gorm.DB, uid, tfNum string) (count int64, err error) {
	if err = tx.Model(&model.ArtworkCopyDetail{}).Where("batch_uid = ? AND tf_num = ?", uid, tfNum).Count(&count).Error; err != nil {
		zap.L().Error("get artworkCopyDetail num err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func IsExistArtworkSoldTxDetail(tx *gorm.DB, uid, tfNum string) (count int64, err error) {
	if err = tx.Model(&model.ArtworkSoldTxDetail{}).Where("batch_uid = ? AND tf_num = ?", uid, tfNum).Count(&count).Error; err != nil {
		zap.L().Error("get artworkSoldTxDetail num err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func IsExistArtworkSoldCopyDetail(tx *gorm.DB, uid, tfNum string) (count int64, err error) {
	if err = tx.Model(&model.ArtworkSoldCopyDetail{}).Where("batch_uid = ? AND tf_num = ?", uid, tfNum).Count(&count).Error; err != nil {
		zap.L().Error("get artworkSoldCopyDetail num err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func CreateArtworkSoldTxDetail(tx *gorm.DB, uid1, uid2 string, excelTwoInfo *statement.ExcelTwoInfo) (err error) {
	fmt.Println("excelTwoInfo:", excelTwoInfo)
	fmt.Println("excelTwoInfo.CompleteDate:", excelTwoInfo.CompleteDate)
	artworkSoldTxDetail := &model.ArtworkSoldTxDetail{
		Uid:          uid2,
		BatchUid:     uid1, //批次uid
		TfNum:        excelTwoInfo.TfNum,
		ArtworkName:  excelTwoInfo.ArtworkName,
		Ruler:        excelTwoInfo.Ruler,
		SaleNo:       excelTwoInfo.SaleNo,
		CompleteDate: excelTwoInfo.CompleteDate,
		SalePrice:    excelTwoInfo.SalePrice,
	}

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

	return
}

func CreateArtworkSoldCopyDetail(tx *gorm.DB, uid1, uid2 string, excelTwoInfo *statement.ExcelTwoInfo) (err error) {
	artworkSoldCopyDetail := &model.ArtworkSoldCopyDetail{
		Uid:          uid2,
		BatchUid:     uid1, //批次uid
		TfNum:        excelTwoInfo.TfNum,
		ArtworkName:  excelTwoInfo.ArtworkName,
		Ruler:        excelTwoInfo.Ruler,
		SaleNo:       excelTwoInfo.SaleNo,
		CompleteDate: excelTwoInfo.CompleteDate,
		SalePrice:    excelTwoInfo.SalePrice,
	}

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

	return
}

func GetAllBatchTimeTx() (batchTime []string, err error) {
	if err = db.DB.Distinct("batch_time").Find(&model.ArtworkTx{}).Pluck("batch_time", &batchTime).Error; err != nil {
		zap.L().Error("get artworkTxList info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func GetAllBatchTimeCopy() (batchTime []string, err error) {
	if err = db.DB.Distinct("batch_time").Find(&model.ArtworkCopy{}).Pluck("batch_time", &batchTime).Error; err != nil {
		zap.L().Error("get artworkTxList info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func GetArtworkTxList(query *gorm.DB, num, offset int32) (artworkTxList []model.ArtworkTx, err error) {
	if err = query.Find(&artworkTxList).Order("ID asc").Limit(int(num)).Offset(int(offset)).Error; err != nil {
		zap.L().Error("get artworkTxList info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func GetArtworkCopyList(query *gorm.DB, num, offset int32) (artworkCopyList []model.ArtworkCopy, err error) {
	if err = query.Find(&artworkCopyList).Order("ID asc").Limit(int(num)).Offset(int(offset)).Error; err != nil {
		zap.L().Error("get artworkCopyList info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func GetArtworkSoldTxDetailList(batchUid string) (artworkSoldTxDetail []model.ArtworkSoldTxDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkSoldTxDetail).Error; err != nil {
		zap.L().Error("get artworkSoldTxDetail info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func GetArtworkSoldCopyDetailList(batchUid string) (artworkSoldCopyDetail []model.ArtworkSoldCopyDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkSoldCopyDetail).Error; err != nil {
		zap.L().Error("get artworkSoldCopyDetail info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	return
}

func UpdateArtworkTxStatus(tx *gorm.DB, batchUid string, state int32) (err error) {
	if err = tx.Model(&model.ArtworkTx{}).Where("uid = ?", batchUid).Update("state", 2).Error; err != nil {
		zap.L().Error("update artworkTx info err", zap.Error(err))
		err = errors.New(m.UPDATE_FAILED)
		return
	}

	return
}

func UpdateArtworkCopyStatus(tx *gorm.DB, batchUid string, state int32) (err error) {
	if err = tx.Model(&model.ArtworkCopy{}).Where("uid = ?", batchUid).Update("state", 2).Error; err != nil {
		zap.L().Error("update artworkCopy info err", zap.Error(err))
		err = errors.New(m.UPDATE_FAILED)
		return
	}

	return
}

func StatementList(artistUid string, state int32) (contractData []*statement.Contracts, err error) {

	var contracts []model.Contract
	if err = db.DB.Where("artist_uid = ? AND  state = ? AND (type == 4 OR type == 7)", artistUid, state).Find(&contracts).Error; err != nil {
		zap.L().Error("get contracts info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	for _, v := range contracts {
		Contract := &statement.Contracts{
			ContractUid:   v.Uid,
			ArtistUid:     v.ArtistUid,
			ArtworkUid:    v.ArtworkUid,
			ContractId:    v.ContractId,
			TransactionId: v.TransactionId,
			Type:          v.Type,
			ViewUrl:       v.ViewUrl,
			DownloadUrl:   v.DownloadUrl,
			State:         v.State,
			Status:        int32(v.Status),
			LockTime:      v.LockTime,
			SignTime:      v.SignTime,
			BatchTime:     v.BatchTime,
			BatchUid:      v.BatchUid,
		}

		contractData = append(contractData, Contract)
	}

	return
}

func GetTxArtistNameByBatchUid(batchUid string) (artworkTx model.ArtworkTx, err error) {
	if err = db.DB.Where("uid = ?", batchUid).Find(&artworkTx).Error; err != nil {
		zap.L().Error("get artworkTx info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}

func GetArtworkTxDetailByBatchUid(batchUid string) (artworkTxDetail []model.ArtworkTxDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkTxDetail).Error; err != nil {
		zap.L().Error("get artworkTxDetail infos err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}

func GetArtworkSoldTxDetailByBatchUid(batchUid string) (artworkSoldTxDetail []model.ArtworkSoldTxDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkSoldTxDetail).Error; err != nil {
		zap.L().Error("get artworkSoldTxDetail infos err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}

func GetCopyArtistNameByBatchUid(batchUid string) (artworkCopy model.ArtworkCopy, err error) {
	if err = db.DB.Where("uid = ?", batchUid).Find(&artworkCopy).Error; err != nil {
		zap.L().Error("get artworkCopy info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}

func GetArtworkCopyDetailByBatchUid(batchUid string) (artworkCopyDetail []model.ArtworkCopyDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkCopyDetail).Error; err != nil {
		zap.L().Error("get artworkCopyDetail infos err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}

func GetArtworkSoldCopyDetailByBatchUid(batchUid string) (artworkSoldCopyDetail []model.ArtworkSoldCopyDetail, err error) {
	if err = db.DB.Where("batch_uid = ?", batchUid).Find(&artworkSoldCopyDetail).Error; err != nil {
		zap.L().Error("get artworkSoldCopyDetail infos err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}

	return
}