package department

import (
	"encoding/json"
	"time"

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

type SyncDataDepartmentService struct{}

// type BusinessAdminCommand struct {
// 	// department:部门
// 	Module string `json:"module"`
// 	// add:添加,edit:编辑,batchDelete:批量删除,import:导入部门
// 	Action string `json:"action"`
// 	// 具体的对象JSON数据
// 	Datas json.RawMessage `json:"data"`
// }

func (srv SyncDataDepartmentService) FromBusinessAdmin(param *domain.MessageBody) error {
	action := param.Module + "/" + param.Action
	var err error
	switch action {
	case "department/add":
		var param1 command.AddDepartmentCommand
		err = json.Unmarshal(param.Datas, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.addDepartment(&param1)
	case "department/edit":
		var param1 command.EditDepartmentCommand
		err = json.Unmarshal(param.Datas, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.editDepartment(&param1)
	case "department/batchDelete":
		var param1 command.BatchDeleteCommand
		err = json.Unmarshal(param.Datas, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.batchDeleteDepartment(&param1)
	case "department/import":
		var param1 []command.ImportDepartmentCommand
		err = json.Unmarshal(param.Datas, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = srv.importDepartment(param1)
	}
	return err
}

//AddDepartment
//从BusinessAdmins 接收消息 添加部门
//module="department" action="add"
func (srv SyncDataDepartmentService) addDepartment(param *command.AddDepartmentCommand) 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()
	newDepartment := domain.Department{
		Id:            param.Id,
		CompanyId:     param.CompanyId,
		Level:         param.Level,
		Name:          param.Name,
		ParentId:      param.ParentId,
		ChargeUserIds: param.ChargeUserIds,
		Path:          param.Path,
		CreateAt:      nowTime,
		UpdateAt:      nowTime,
		DeleteAt:      nil,
	}

	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, err = departmentRepo.Insert(&newDepartment)
	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
}

//EditDepartment
//从BusinessAdmins 接收消息 编辑部门
//module="department" action="edit"
func (srv SyncDataDepartmentService) editDepartment(param *command.EditDepartmentCommand) 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()
	}()

	departmentIds := []int64{param.Id}
	for _, v := range param.ChangeDepartmentLists {
		departmentIds = append(departmentIds, v.Id)
	}
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, departmentList, err := departmentRepo.Find(map[string]interface{}{
		"ids": departmentIds,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range departmentList {
		if departmentList[i].Id == param.Id {
			departmentList[i].CompanyId = param.CompanyId
			departmentList[i].Name = param.Name
			departmentList[i].Name = param.Path
			departmentList[i].ChargeUserIds = param.ChargeUserIds
			departmentList[i].Level = param.Level
			departmentList[i].ParentId = param.ParentId
			continue
		}

		for _, vv := range param.ChangeDepartmentLists {
			if vv.Id == departmentList[i].Id {
				departmentList[i].Path = vv.Path
				departmentList[i].Level = vv.Level
				break
			}
		}
	}
	for i := range departmentList {
		_, err := departmentRepo.Update(departmentList[i])
		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
}

//batchDelete
//从BusinessAdmins 接收消息 删除部门
//module="department" action="batchDelete"
func (srv SyncDataDepartmentService) batchDeleteDepartment(param *command.BatchDeleteCommand) error {
	if len(param.Ids) == 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()
	}()
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	err = departmentRepo.Remove(param.Ids)
	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
}

//importDepartment
//从BusinessAdmins 接收消息 导入部门数据
//module="department" action="import"
func (srv SyncDataDepartmentService) importDepartment(param []command.ImportDepartmentCommand) 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()
	}()
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	nowTime := time.Now()
	for i := range param {
		newDepartment := domain.Department{
			Id:            param[i].Id,
			CompanyId:     param[i].CompanyId,
			Level:         param[i].Level,
			Name:          param[i].Name,
			ParentId:      param[i].ParentId,
			ChargeUserIds: []int64{},
			Path:          param[i].Path,
			CreateAt:      nowTime,
			UpdateAt:      nowTime,
			DeleteAt:      nil,
		}
		_, err = departmentRepo.Insert(&newDepartment)
		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
}