package user

import (
	"encoding/json"
	"time"

	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/log"

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

// type BusinessAdminCommand struct {
// 	// employee:员工
// 	Module string `json:"module"`
// 	// add:添加,edit:编辑,batchDelete:批量删除,batchForbid:批量禁用用户，batchRemove：批量更改用户部门,import:导入用户
// 	Action string `json:"action"`
// 	// 具体的对象JSON数据
// 	Data json.RawMessage `json:"data"`
// }

func (srv SyncDataUserService) FromBusinessAdmin(param *domain.MessageBody) error {
	action := param.Module + "/" + param.Action
	var err error
	switch action {
	case "employee/add":
		var param1 command.SaveUserCommand
		err = json.Unmarshal(param.Data, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.AddUser(&param1)
	case "employee/edit":
		var param2 command.SaveUserCommand
		err = json.Unmarshal(param.Data, &param2)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.UpdateUser(&param2)
	case "employee/batchDelete":
		var param3 command.BatchDeleteCommand
		err = json.Unmarshal(param.Data, &param3)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.batchDelete(&param3)
	case "employee/batchForbid":
		var param4 command.BatchForbidCommand
		err = json.Unmarshal(param.Data, &param4)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.batchForbid(&param4)
	case "employee/import":
		var param4 command.ImportUserCommand
		err = json.Unmarshal(param.Data, &param4)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.importUser(&param4)
	case "employee/batchRemove":
		batchRemove := &command.BatchRemove{}
		err = json.Unmarshal(param.Data, batchRemove)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.BatchRemove(batchRemove)
	default:
		log.Logger.Error("action err:" + action)
	}

	return err
}

// 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,
		DepartmentId: param.DepartmentIds(),
		PositionId:   param.PositionIds(),
		Name:         param.Name,
		Email:        param.Email,
		Status:       param.Status,
		EntryTime:    param.EntryTime,
		UpdatedAt:    nowTime,
		CreatedAt:    nowTime,
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, err = userRepo.Insert(&newUser)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	var (
		newUser *domain.User
	)
	nowTime := time.Now()
	if len(userList) > 0 {
		newUser = userList[0]
	} else {
		newUser = &domain.User{
			CreatedAt: 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.EntryTime = param.EntryTime
	newUser.PositionId = param.PositionIds()
	newUser.DepartmentId = param.DepartmentIds()

	newUser.UpdatedAt = nowTime
	if len(userList) > 0 {
		_, err = userRepo.Update(newUser)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	} else {
		_, err = userRepo.Insert(newUser)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range userList {
		userList[i].Status = param.Status
		_, err = userRepo.Update(userList[i])
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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]
	}
	nowTime := time.Now()
	if len(editUserIds) > 0 {
		_, editUserList, err := userRepo.Find(map[string]interface{}{
			"ids": editUserIds,
		})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		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].EntryTime = mVal.EntryTime
			editUserList[i].UpdatedAt = nowTime
			_, err = userRepo.Update(editUserList[i])
			if err != nil {
				return err
			}
		}
	}
	var (
		tempUser domain.User
	)
	if len(param.AddUsers) > 0 {
		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,
				EntryTime: param.AddUsers[i].EntryTime,
				UpdatedAt: nowTime,
				DeletedAt: nil,
				CreatedAt: nowTime,
			}
			_, err := userRepo.Insert(&tempUser)
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	return nil
}

// BatchRemove 调整部门
func (srv SyncDataUserService) BatchRemove(batchRemove *command.BatchRemove) 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,
	})
	if len(batchRemove.UserIds) > 0 {
		for _, item := range batchRemove.UserIds {
			user, err := userRepo.FindOne(map[string]interface{}{"id": item, "companyId": batchRemove.CompanyId})
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			user.DepartmentId = batchRemove.DepartmentIds
			user.UpdatedAt = time.Now()
			_, err = userRepo.Update(user)
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}