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数据
// 	Datas 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.Datas, &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.Datas, &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.Datas, &param3)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.batchDelete(&param3)
	case "company/batchForbid":
		var param4 command.BatchForbidCommand
		err = json.Unmarshal(param.Datas, &param4)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.batchForbid(&param4)
	case "company/import":
		var param4 command.ImportUserCommand
		err = json.Unmarshal(param.Datas, &param4)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.importUser(&param4)
	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()
	}()
	var departmentIds []int
	for _, v := range param.UserDepartments {
		departmentIds = append(departmentIds, v.DepartmentId)
	}
	nowTime := time.Now()
	newUser := domain.User{
		Id:           param.Id,
		Account:      param.Phone,
		AvatarUrl:    param.Avatar,
		CompanyId:    param.CompanyId,
		AdminType:    param.AdminType,
		DepartmentId: departmentIds,
		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 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{
			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 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]
	}
	_, editUserList, err := userRepo.Find(map[string]interface{}{
		"ids": editUserIds,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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 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
}