package domainService

import (
	"fmt"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-user/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-user/pkg/infrastructure/repository"
	"time"
)

// PgBatchAddUserService 批量创建用户服务
type PgBatchAddUserService struct {
	transactionContext *pgTransaction.TransactionContext
}

// CreateUser  批量添加用户服务
//
// optUser 操作用户
// users  待添加用户列表数据
// password 密码
func (ptr *PgBatchAddUserService) BatchAddUser(optUser *domain.OperateInfo, users []*domain.User, password string) error {
	var (
		err error
	)
	orgRepository, err := repository.NewOrgRepository(ptr.transactionContext)
	if err != nil {
		return err
	}
	_, orgs, err := orgRepository.Find(map[string]interface{}{"companyId": optUser.CompanyId})
	if err != nil {
		return err
	}
	var mapOrg = make(map[int64]*domain.Org)
	for i := range orgs {
		mapOrg[orgs[i].OrgId] = orgs[i]
	}

	createUserService, _ := NewPgCreateUserService(ptr.transactionContext)
	for i := range users {
		user := users[i]
		if err = ptr.preCheck(user); err != nil {
			return err
		}
		newUser := &domain.User{
			CompanyId:       user.CompanyId,
			UserType:        user.UserType,
			UserCode:        user.UserCode,
			OrganizationId:  user.OrganizationId,
			DepartmentId:    user.DepartmentId,
			UserOrg:         []*domain.Org{},
			UserRole:        []*domain.Role{},
			FavoriteMenus:   []string{},
			CooperationInfo: user.CooperationInfo,
			UserInfo:        user.UserInfo,
			EnableStatus:    int(domain.UserStatusEnable),
			Ext: &domain.Ext{
				Phone:    user.UserInfo.Phone,
				UserName: user.UserInfo.UserName,
			},
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		if user.OrganizationId > 0 {
			if v, ok := mapOrg[user.OrganizationId]; ok && v.CompanyId == user.CompanyId {
				newUser.Ext.OrgName = v.OrgName
			} else {
				return fmt.Errorf("导入的组织机构不存在")
			}
		}
		if user.DepartmentId > 0 {
			if v, ok := mapOrg[user.DepartmentId]; ok && v.CompanyId == user.CompanyId {
				newUser.Ext.DepName = v.OrgName
			} else {
				return fmt.Errorf("导入的所属部门不存在")
			}
		}

		if newUser, err = createUserService.CreateUser(nil, newUser, password); err != nil {
			return err
		}
	}
	return nil
}

func (ptr *PgBatchAddUserService) BatchAddUser2(optUser *domain.OperateInfo, users []*domain.BatchAddUserItem, password string) ([]*domain.BatchAddUserItem, error) {
	var (
		err error
	)
	var failRows = make([]*domain.BatchAddUserItem, 0)
	orgRepository, err := repository.NewOrgRepository(ptr.transactionContext)
	if err != nil {
		return failRows, err
	}
	_, orgs, err := orgRepository.Find(map[string]interface{}{"companyId": optUser.CompanyId, "limit": 10000})
	if err != nil {
		return failRows, err
	}
	var mapOrg = make(map[string]*domain.Org)
	for i := range orgs {
		mapOrg[orgs[i].OrgCode] = orgs[i]
	}

	createUserService, _ := NewPgCreateUserService(ptr.transactionContext)
	for i := range users {
		user := users[i]
		if err = ptr.preCheck2(user); err != nil {
			user.FailReason = err.Error()
			failRows = append(failRows, user)
			continue
			//return err
		}
		var org, dep *domain.Org
		var ok bool
		if org, ok = mapOrg[user.Org]; !ok {
			user.FailReason = "导入的组织机构不存在:" + user.Org
			failRows = append(failRows, user)
			continue
			//return fmt.Errorf("导入的组织机构不存在:" + user.Org)
		}
		if dep, ok = mapOrg[user.Department]; !ok {
			user.FailReason = "导入的所属部门不存在:" + user.Department
			failRows = append(failRows, user)
			continue
			//return fmt.Errorf("导入的所属部门不存在:" + user.Department)
		}
		newUser := &domain.User{
			CompanyId:      user.CompanyId,
			UserType:       user.UserType,
			UserCode:       user.UserCode,
			OrganizationId: org.OrgId,
			DepartmentId:   dep.OrgId,
			UserOrg:        []*domain.Org{},
			UserRole:       []*domain.Role{},
			FavoriteMenus:  []string{},
			CooperationInfo: &domain.CooperationInfo{
				CooperationCompany:  user.CooperationCompany,
				CooperationDeadline: user.CooperationDeadline,
			},
			UserInfo: &domain.UserInfo{
				UserName: user.UserName,
				Phone:    user.Phone,
				Avatar:   "",
				Email:    user.Email,
			},
			EnableStatus: int(domain.UserStatusEnable),
			Ext: &domain.Ext{
				Phone:    user.Phone,
				UserName: user.UserName,
				OrgName:  org.OrgName,
				DepName:  dep.OrgName,
			},
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		if newUser, err = createUserService.CreateUser(nil, newUser, password); err != nil {
			user.FailReason = err.Error()
			failRows = append(failRows, user)
			continue
			//return fmt.Errorf("%v %v", user.UserName, err.Error())
		}
	}
	return failRows, nil
}

func (ptr *PgBatchAddUserService) preCheck(user *domain.User) error {
	if len(user.UserCode) == 0 {
		return fmt.Errorf("导入的用户编码为空值")
	}
	if len(user.UserInfo.UserName) == 0 {
		return fmt.Errorf("导入的用户姓名为空值")
	}
	if len(user.UserInfo.Phone) == 0 {
		return fmt.Errorf("导入的手机号不是有效手机号")
	}
	if user.OrganizationId == 0 {
		return fmt.Errorf("导入的组织机构不存在")
	}
	if user.DepartmentId == 0 && user.UserType == domain.UserTypeEmployee {
		return fmt.Errorf("导入的所属部门不存在")
	}
	return nil
}

func (ptr *PgBatchAddUserService) preCheck2(user *domain.BatchAddUserItem) error {
	if len(user.UserName) == 0 {
		return fmt.Errorf("导入的用户姓名为空值")
	}
	if len(user.Phone) == 0 {
		return fmt.Errorf("导入的手机号不是有效手机号")
	}
	//if len(user.Org) == 0 {
	//	return fmt.Errorf("导入的组织机构不存在")
	//}
	//if len(user.Department) == 0 && user.UserType == domain.UserTypeEmployee {
	//	return fmt.Errorf("导入的所属部门不存在")
	//}
	return nil
}

func NewPgBatchAddUserService(transactionContext *pgTransaction.TransactionContext) (*PgBatchAddUserService, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &PgBatchAddUserService{
			transactionContext: transactionContext,
		}, nil
	}
}