package controller

import (
	"context"
	"fmt"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"gorm.io/gorm"

	"github.com/fonchain/fonchain-artistinfo/cmd/internal/logic"
	"github.com/fonchain/fonchain-artistinfo/pb/artistinfo"
)

var _ artistinfo.ArtistInfoServer = new(ArtistInfoProvider)

type ArtistInfoProvider struct {
	artistinfo.UnimplementedArtistInfoServer
	artistInfoLogic *logic.ArtistInfo
}

func (a *ArtistInfoProvider) RegisterUser(ctx context.Context, req *artistinfo.RegisterUserRequest) (rep *artistinfo.RegisterUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.RegisterUser(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) UpdateIdCard(ctx context.Context, in *artistinfo.UpdateIdCardRequest) (rep *artistinfo.CommonNoParams, err error) {
	var thisUser model.User
	db.DB.Where("mgmt_acc_id = ?", in.MgmtAccId).Preload("RealNameInfo").Find(&thisUser)
	if thisUser.RealNameInfo == nil {
		thisUser.RealNameInfo = &model.RealName{}
	}
	if in.Name != "" {
		thisUser.RealNameInfo.Name = in.Name
	}
	if in.IdNum != "" {
		thisUser.RealNameInfo.IdNum = in.IdNum
	}
	if in.Age != 0 {
		thisUser.RealNameInfo.Age = int(in.Age)
	}
	if in.Sex != "" {
		thisUser.RealNameInfo.Sex = model.SexType(in.Sex)
	}
	if in.Address != "" {
		thisUser.RealNameInfo.Address = in.Address
	}
	if in.IdCardFront != "" {
		thisUser.RealNameInfo.IdCardFront = in.IdCardFront
	}
	if in.IdCardBack != "" {
		thisUser.RealNameInfo.IdCardBack = in.IdCardBack
	}
	if in.Birthday != "" {
		thisUser.RealNameInfo.Birthday = in.Birthday
	}
	err = db.DB.Session(&gorm.Session{FullSaveAssociations: true}).Save(&thisUser).Error
	return
}

func (a *ArtistInfoProvider) GetUser(ctx context.Context, req *artistinfo.GetUserRequest) (rep *artistinfo.GetUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.GetUser(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) GetUserById(ctx context.Context, req *artistinfo.GetUserByIdRequest) (rep *artistinfo.GetUserByIdRespond, err error) {
	return a.artistInfoLogic.GetUserById(req)
}

//func (a *ArtistInfoProvider) UpdateRealName(ctx context.Context, req *artistinfo.UpdateRealNameRequest) (rep *artistinfo.UpdateRealNameRespond, err error) {
//	fmt.Println("第一处")
//	// backup := &artistInfo.GetUserInfoRespond{}
//	if rep, err = a.artistInfoLogic.UpdateRealName(req); err != nil {
//		return nil, err
//	}
//	return rep, nil
//}

func (a *ArtistInfoProvider) FinishVerify(ctx context.Context, req *artistinfo.FinishVerifyRequest) (rep *artistinfo.FinishVerifyRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.FinishVerify(req); err != nil {
		return nil, err
	}
	return rep, nil
}
func (a *ArtistInfoProvider) UserLock(ctx context.Context, req *artistinfo.UserLockRequest) (rep *artistinfo.UserLockRespond, err error) {
	return a.artistInfoLogic.UserLock(req)
}
func (a *ArtistInfoProvider) CheckUserLock(ctx context.Context, req *artistinfo.CheckUserLockRequest) (rep *artistinfo.CheckUserLockRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.CheckUserLock(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) ArtistSupplyList(ctx context.Context, req *artistinfo.ArtistSupplyListRequest) (rep *artistinfo.ArtistSupplyListRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.ArtistSupplyList(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) CheckInvitedCode(ctx context.Context, req *artistinfo.CheckInvitedCodeRequest) (rep *artistinfo.GetUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.CheckInvitedCodeInfoRespond{}
	if rep, err = a.artistInfoLogic.CheckInvitedCode(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) UnFinishList(ctx context.Context, req *artistinfo.UnFinishListRequest) (rep *artistinfo.UnFinishListRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.UnFinishListInfoRespond{}
	if rep, err = a.artistInfoLogic.UnFinishList(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) GetUserMsg(ctx context.Context, req *artistinfo.GetUserMsgRequest) (rep *artistinfo.GetUserMsgRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserMsgInfoRespond{}
	if rep, err = a.artistInfoLogic.GetUserMsg(req); err != nil {
		return nil, err
	}
	return rep, nil
}

// 绑定邀请人和受邀请人的账号,并加入到次数统计
func (a *ArtistInfoProvider) BindInviteInvitedAccount(ctx context.Context, in *artistinfo.BindInviteInvitedAccountRequest) (res *artistinfo.BindInviteInvitedAccountRespond, err error) {
	if in.UserId == 0 || in.InvitedUserId == 0 {
		return nil, err
	}
	// todo 变量in 参数检测: 邀请码没填的话需要从账号服务获取
	// ..
	// ..
	var data model.Invite
	// 只能绑定一个邀请人
	if err = db.DB.Where("invited_id = ?", in.InvitedUserId).Find(&data).Error; err != nil {
		return nil, err
	}
	if data.UserId == 0 {
		data = model.Invite{
			UserId:      in.UserId,
			InvitedId:   in.InvitedUserId,
			InvitedCode: in.InvitedCode,
			InviteCode:  in.InviteCode,
		}
		if err = db.DB.Create(&data).Error; err != nil {
			return nil, err
		}
	}

	// 添加到次数统计
	var countData model.UserInvited
	if err = db.DB.Where("user_id= ? AND invited_user_id= ?", in.UserId, in.GetInvitedUserId()).Find(&countData).Error; err != nil {
		return nil, err
	}
	if countData.UserId == 0 {
		countData = model.UserInvited{
			UserId:        in.UserId,
			InvitedUserId: in.InvitedUserId,
			Count:         1,
			InvitedCode:   in.InvitedCode,
			InviteCode:    in.InviteCode,
		}
		if err = db.DB.Create(&countData).Error; err != nil {
			return nil, err
		}
	} else {
		countData.Count += 1
		if err = db.DB.Model(model.UserInvited{}).Where("id = ?", countData.ID).Updates(&countData).Error; err != nil {
			return nil, err
		}
	}
	return nil, err
}

func (a *ArtistInfoProvider) BindArtistId(ctx context.Context, in *artistinfo.BindArtistIdRequest) (*artistinfo.BindArtistIdResp, error) {
	var updateData = map[string]any{
		"mgmt_artist_id":  in.ArtistId,
		"mgmt_artist_uid": in.ArtistUid,
		"fdd_state":       2,
	}
	if err := db.DB.Model(model.User{}).Where("mgmt_acc_id = ?", in.UserId).Updates(&updateData).Error; err != nil {
		return &artistinfo.BindArtistIdResp{Error: err.Error()}, err
	}
	return nil, nil
}

func (a *ArtistInfoProvider) FindUser(ctx context.Context, in *artistinfo.FindUserRequest) (*artistinfo.UserInfo, error) {
	return a.artistInfoLogic.FindUser(in)
}

func (a *ArtistInfoProvider) UpdateUserData(ctx context.Context, in *artistinfo.UserInfo) (*artistinfo.CommonNoParams, error) {
	return a.artistInfoLogic.UpdateUserData(in)
}

func (a *ArtistInfoProvider) PreSaveArtistInfo(ctx context.Context, in *artistinfo.PreSaveArtistInfoData) (res *artistinfo.CommonNoParams, er error) {
	return a.artistInfoLogic.PreSaveArtistInfo(in)
}
func (a *ArtistInfoProvider) GetPreSaveArtistInfo(ctx context.Context, in *artistinfo.GetPreSaveArtistInfoRequest) (res *artistinfo.PreSaveArtistInfoData, err error) {
	return a.artistInfoLogic.GetPreSaveArtistInfo(in)
}