package logic

import (
	"errors"

	"github.com/fonchain/fonchain-artistinfo/cmd/internal/dao"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/mgmtStatement"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	uuid "github.com/satori/go.uuid"
)

type IMgmtStatement interface {
	AddBatchDetail(in *mgmtStatement.AddBatchDetailreq) (*mgmtStatement.AddBatchDetailres, error)
	UploadExcelOne(in *mgmtStatement.UploadExcelOnereq) (*mgmtStatement.UploadExcelOneres, error)
	UploadExcelTwo(in *mgmtStatement.UploadExcelTworeq) (*mgmtStatement.UploadExcelTwores, error)
	ArtistStatementList(in *mgmtStatement.ArtistStatementListreq) (*mgmtStatement.ArtistStatementListres, error)
	ArtStatementList(in *mgmtStatement.ArtStatementListreq) (*mgmtStatement.ArtStatementListres, error)
	ExportContract(in *mgmtStatement.ExportContractreq) (*mgmtStatement.ExportContractres, error)
	UpdateState(in *mgmtStatement.UpdateStatementreq) error
	CreateTxContract(in *mgmtStatement.CreateTxContractreq) (resp *mgmtStatement.CreateTxContractres, err error)
}

func NewMgmtStatement() IMgmtStatement {
	return &MgmtStatement{}
}

type MgmtStatement struct{}

//通过excel生成一条批次数据
func (a *MgmtStatement) AddBatchDetail(in *mgmtStatement.AddBatchDetailreq) (resp *mgmtStatement.AddBatchDetailres, err error) {
	resp = &mgmtStatement.AddBatchDetailres{}
	var uid uuid.UUID
	if uid, err = uuid.NewV4(); err != nil {
		err = errors.New(m.ERROR_UID)
		return
	}
	if err != nil {
		return nil, err
	}
	var data model.ArtworkTx
	data.Uid = uid.String()
	data.ArtistName = in.ArtistName
	data.ArtistUid = in.ArtistUid
	data.BatchTime = in.BatchTime
	data.StType = in.StType //对账单类型：1=版权 2=物权
	data.Status = 1         //对账单状态 1.未签署  2.已发送未签署  3.已签署
	if err = dao.AddBatchDetail(&data); err != nil {
		return
	}
	respData := &mgmtStatement.AddBatchRes{BatchUid: data.Uid}
	resp.Data = respData
	return
}

//生成一条对账单记录（附件一）
func (a *MgmtStatement) UploadExcelOne(in *mgmtStatement.UploadExcelOnereq) (resp *mgmtStatement.UploadExcelOneres, err error) {
	resp = &mgmtStatement.UploadExcelOneres{}
	var uid uuid.UUID
	if uid, err = uuid.NewV4(); err != nil {
		err = errors.New(m.ERROR_UID)
		return
	}
	if err != nil {
		return nil, err
	}
	var data model.ArtworkSoldTxDetail //物权版权的对账单

	sqlSelect := `select uid from artwork_tx where artistid = ? and batchtime = ?`
	var batchid string
	if err := db.DB.Raw(sqlSelect, data.ArtistUid, data.BatchTime).Find(&batchid).Error; err != nil {
		return nil, err
	}

	data.Uid = uid.String()
	data.BatchUid = batchid
	data.ArtworkName = in.ArtworkName
	data.ArtistName = in.ArtistName
	data.ArtistUid = in.ArtistUid
	data.TfNum = in.TfNum
	data.BatchTime = in.BatchTime
	data.GuaranteePrice = in.GuaranteePrice
	data.Ruler = in.Ruler
	data.MinPrice = in.MinPrice
	data.StType = in.StType //对账单类型：1=版权 2=物权
	if err = dao.UploadExcelOne(&data); err != nil {
		return
	}
	respData := &mgmtStatement.StatementAddRes{StatementUid: data.Uid}
	resp.Data = respData
	return
}

//生成一条对账单记录（附件二）
func (a *MgmtStatement) UploadExcelTwo(in *mgmtStatement.UploadExcelTworeq) (resp *mgmtStatement.UploadExcelTwores, err error) {
	resp = &mgmtStatement.UploadExcelTwores{}
	var uid uuid.UUID
	if uid, err = uuid.NewV4(); err != nil {
		err = errors.New(m.ERROR_UID)
		return
	}
	if err != nil {
		return nil, err
	}
	var data model.ArtworkSoldTxDetail //物权版权的对账单

	sqlSelect := `select uid from artwork_tx_batch where artistid = ? and batchtime = ?`
	var batchid string
	if err := db.DB.Raw(sqlSelect, data.ArtistUid, data.BatchTime).Find(&batchid).Error; err != nil {
		return nil, err
	}

	data.Uid = uid.String()
	data.BatchUid = batchid
	data.ArtworkName = in.ArtworkName
	data.ArtistName = in.ArtistName
	data.ArtistUid = in.ArtistUid
	data.TfNum = in.TfNum
	data.BatchTime = in.BatchTime
	data.Ruler = in.Ruler
	data.MinPrice = in.MinPrice
	data.StType = in.StType //对账单类型：1=版权 2=物权
	if err = dao.UploadExcelTwo(&data); err != nil {
		return
	}
	respData := &mgmtStatement.StatementAddRes{StatementUid: data.Uid}
	resp.Data = respData
	return
}

//画家对账单列表
func (a *MgmtStatement) ArtistStatementList(in *mgmtStatement.ArtistStatementListreq) (resp *mgmtStatement.ArtistStatementListres, err error) {
	resp = &mgmtStatement.ArtistStatementListres{}
	if in.Page < model.InitPage {
		in.Page = model.InitPage
	}
	if in.PageSize < 1 {
		in.PageSize = model.PageSize
	}
	var list []*model.ArtworkSoldTxDetail
	var count int64
	if list, count, err = dao.ArtistStatementList(in); err != nil {
		return
	}
	resp.Count = int32(count)
	resp.Page = in.Page
	resp.PageSize = in.PageSize
	for _, v := range list {
		temp := mgmtStatement.ArtistStatementListres_Info{}
		temp.ArtistName = v.ArtistName
		temp.ArtistUid = v.ArtistUid
		temp.BatchTime = v.BatchTime
		resp.Data = append(resp.Data, &temp)
	}
	return
}

//画作列表，根据画家和批次
func (a *MgmtStatement) ArtStatementList(in *mgmtStatement.ArtStatementListreq) (resp *mgmtStatement.ArtStatementListres, err error) {
	resp = &mgmtStatement.ArtStatementListres{}
	if in.Page < model.InitPage {
		in.Page = model.InitPage
	}
	if in.PageSize < 1 {
		in.PageSize = model.PageSize
	}
	var list []*model.ArtworkSoldTxDetail
	var count int64
	if list, count, err = dao.ArtStatementList(in); err != nil {
		return
	}
	resp.Count = int32(count)
	resp.Page = in.Page
	resp.PageSize = in.PageSize
	for _, v := range list {
		temp := mgmtStatement.ArtStatementListres_Info{}
		temp.ArtistName = v.ArtworkName
		temp.ArtistUid = v.ArtistUid
		temp.ArtworkName = v.ArtworkName
		temp.Ruler = v.Ruler
		temp.SaleNo = v.SaleNo
		temp.TfNum = v.TfNum
		temp.CompleteDate = v.CompleteDate
		temp.MinPrice = v.MinPrice
	}
	return
}

//更新对账单状态
func (a *MgmtStatement) UpdateState(in *mgmtStatement.UpdateStatementreq) (err error) {
	columns := map[string]interface{}{
		"status": in.Status, //状态
	}
	if err = dao.UpdateState(in.StatementUid, columns); err != nil {
		return
	}
	return
}

//导出合同
func (a *MgmtStatement) ExportContract(in *mgmtStatement.ExportContractreq) (resp *mgmtStatement.ExportContractres, err error) {
	resp = &mgmtStatement.ExportContractres{}
	if in.Page < model.InitPage {
		in.Page = model.InitPage
	}
	if in.PageSize < 1 {
		in.PageSize = model.PageSize
	}

	var list []*model.Contract
	var count int64
	if list, count, err = dao.ExportContract(in); err != nil {
		return
	}
	resp.Count = int32(count)
	for _, v := range list {
		temp := mgmtStatement.ExportContractres_Info{}
		temp.DownloadUrl = v.DownloadUrl
		temp.BatchTime = v.BatchTime
		temp.StType = v.StType
		temp.ViewUrl = v.ViewUrl
		temp.BatchUid = v.BatchUid
		temp.ArtistUid = v.ArtistUid
		resp.Data = append(resp.Data, &temp)
	}
	return
}

//生成合同
func (a *MgmtStatement) CreateTxContract(in *mgmtStatement.CreateTxContractreq) (resp *mgmtStatement.CreateTxContractres, err error) {
	resp = &mgmtStatement.CreateTxContractres{}

	var uid uuid.UUID
	if uid, err = uuid.NewV4(); err != nil {
		err = errors.New(m.ERROR_UID)
		return
	}
	if err != nil {
		return nil, err
	}

	var data model.Contract
	data.Uid = uid.String()
	data.ArtistUid = in.ArtistUid
	data.BatchTime = in.BatchTime
	data.BatchUid = in.BatchUid
	data.ContractId = in.ContractId
	data.StType = in.StType
	data.Status = 1
	data.DownloadUrl = in.DownloadUrl
	data.ViewUrl = in.ViewUrl
	data.CardId = in.CardId
	if err = dao.CreateTxContract(&data); err != nil {
		return
	}
	respData := &mgmtStatement.AddContractRes{BatchUid: data.Uid}
	resp.Data = respData
	return
}