package user

import (
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/user/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
)

type SyncDataUserService struct{}

//AddUser
//从BusinessAdmins 接收消息 添加用户
//module="employee" action="add"
func (srv SyncDataUserService) AddUser(param command.SaveUserCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	nowTime := time.Now()
	newUser := domain.User{
		Id:        param.Id,
		Account:   param.Phone,
		AvatarUrl: param.Avatar,
		CompanyId: param.CompanyId,
		AdminType: param.AdminType,
		Name:      param.Name,
		Status:    param.Status,
		UpdateAt:  nowTime,
		DeleteAt:  nil,
		CreateAt:  nowTime,
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, err = userRepo.Insert(&newUser)
	if err != nil {
		return err
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	return nil
}

//UpdateUser
//从BusinessAdmins 接收消息 更新用户
//module="employee" action="edit"
func (srv SyncDataUserService) UpdateUser(param command.SaveUserCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, userList, err := userRepo.Find(map[string]interface{}{
		"limit": 1,
		"id":    param.Id,
	})
	if err != nil {
		return err
	}
	var (
		newUser *domain.User
	)
	nowTime := time.Now()
	if len(userList) > 0 {
		newUser = userList[0]
	} else {
		newUser = &domain.User{
			CreateAt: nowTime,
		}
	}
	newUser.Id = param.Id
	newUser.Account = param.Phone
	newUser.AvatarUrl = param.Avatar
	newUser.CompanyId = param.CompanyId
	newUser.AdminType = param.AdminType
	newUser.Name = param.Name
	newUser.Status = param.Status
	newUser.UpdateAt = nowTime
	if len(userList) > 0 {
		_, err = userRepo.Update(newUser)
		if err != nil {
			return err
		}
	} else {
		_, err = userRepo.Insert(newUser)
		if err != nil {
			return err
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	return nil
}

//batchDelete
//从BusinessAdmins 接收消息 删除用户
//module="employee" action="batchDelete"
func (srv SyncDataUserService) batchDelete(param command.BatchDeleteCommand) error {
	if len(param.Uids) == 0 {
		return nil
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	err = userRepo.Remove(param.Uids)
	if err != nil {
		return err
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	return nil
}

//batchForbid
//从BusinessAdmins 接收消息 禁用,启用用户
//module="employee" action="batchForbid"
func (srv SyncDataUserService) batchForbid(param command.BatchForbidCommand) error {
	if len(param.Uids) == 0 {
		return nil
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, userList, err := userRepo.Find(map[string]interface{}{
		"ids":   param.Uids,
		"limit": len(param.Uids),
	})
	if err != nil {
		return err
	}
	for i := range userList {
		userList[i].Status = param.Status
		_, err = userRepo.Update(userList[i])
		if err != nil {
			return err
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	return nil
}

//importUser
//从BusinessAdmins 接收消息 导入用户数据
//module="employee" action="import"
func (srv SyncDataUserService) importUser(param command.ImportUserCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	editUserMap := map[int64]command.SaveUserCommand{}
	var editUserIds []int64
	for i := range param.EditUsers {
		editUserIds = append(editUserIds, param.EditUsers[i].Id)
		editUserMap[param.EditUsers[i].Id] = param.EditUsers[i]
	}
	_, editUserList, err := userRepo.Find(map[string]interface{}{
		"ids": editUserIds,
	})
	if err != nil {
		return err
	}
	nowTime := time.Now()
	for i := range editUserList {
		mVal, ok := editUserMap[editUserList[i].Id]
		if !ok {
			continue
		}
		editUserList[i].Account = mVal.Phone
		editUserList[i].AdminType = mVal.AdminType
		editUserList[i].AvatarUrl = mVal.Avatar
		editUserList[i].Name = mVal.Name
		editUserList[i].Status = mVal.Status
		editUserList[i].CompanyId = mVal.CompanyId
		editUserList[i].UpdateAt = nowTime
		_, err = userRepo.Update(editUserList[i])
		if err != nil {
			return err
		}
	}
	var (
		tempUser domain.User
	)
	for i := range param.AddUsers {
		tempUser = domain.User{
			Id:        param.AddUsers[i].Id,
			Account:   param.AddUsers[i].Phone,
			AvatarUrl: param.AddUsers[i].Avatar,
			CompanyId: param.AddUsers[i].CompanyId,
			AdminType: param.AddUsers[i].AdminType,
			Name:      param.AddUsers[i].Name,
			Status:    param.AddUsers[i].Status,
			UpdateAt:  nowTime,
			DeleteAt:  nil,
			CreateAt:  nowTime,
		}
		_, err := userRepo.Insert(&tempUser)
		if err != nil {
			return err
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}

	return nil
}