package company

import (
	"time"

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

type CompanyServices struct {
}

//从BusinessAdmins 接收消息，变更公司数据
//
func (c CompanyServices) BusinessAdminCompany() error {
	return nil
}

//addCompany
//从BusinessAdmins 接收消息 添加公司
func (c CompanyServices) addCompany(param *command.SaveCompanyCommand) 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()
	newCompany := domain.Company{
		Id:            param.Comapany.Id,
		Logo:          param.Comapany.Logo,
		Name:          param.Comapany.Name,
		Status:        param.Comapany.Status,
		UpdateAt:      nowTime,
		CreateAt:      nowTime,
		ChargeUserIds: []int64{},
		DeleteAt:      nil,
	}

	newUser := domain.User{
		Id:        param.User.Id,
		Account:   param.User.Phone,
		AvatarUrl: param.User.Avatar,
		CompanyId: param.User.CompanyId,
		AdminType: param.User.AdminType,
		Name:      param.User.Name,
		Status:    param.User.Status,
		UpdateAt:  nowTime,
		DeleteAt:  nil,
		CreateAt:  nowTime,
	}
	companyRepo := factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, err = companyRepo.Insert(&newCompany)
	if err != nil {
		return err
	}
	_, err = userRepo.Insert(&newUser)
	if err != nil {
		return err
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

//editCompany
//从BusinessAdmins 接收消息 更新公司
func (c CompanyServices) editCompany(param *command.SaveCompanyCommand) 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()
	}()
	companyRepo := factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, companyList, err := companyRepo.Find(map[string]interface{}{
		"limit": 1,
		"id":    param.Comapany.Id,
	})
	if err != nil {
		return err
	}
	_, userList, err := userRepo.Find(map[string]interface{}{
		"limit": 1,
		"id":    param.User.Id,
	})
	if err != nil {
		return err
	}
	var (
		newCompany *domain.Company
		newUser    *domain.User
	)
	nowTime := time.Now()
	if len(companyList) > 0 {
		newCompany = companyList[0]
	} else {
		newCompany = &domain.Company{
			CreateAt: nowTime,
		}
	}
	if len(userList) > 0 {
		newUser = userList[0]
	} else {
		newUser = &domain.User{
			CreateAt: nowTime,
		}
	}

	newCompany.Id = param.Comapany.Id
	newCompany.Logo = param.Comapany.Logo
	newCompany.Name = param.Comapany.Name
	newCompany.Status = param.Comapany.Status
	newCompany.UpdateAt = nowTime

	newUser.Id = param.User.Id
	newUser.Account = param.User.Phone
	newUser.AvatarUrl = param.User.Avatar
	newUser.CompanyId = param.User.CompanyId
	newUser.AdminType = param.User.AdminType
	newUser.Name = param.User.Name
	newUser.Status = param.User.Status
	newUser.UpdateAt = nowTime
	if len(companyList) > 0 {
		_, err = companyRepo.Update(newCompany)
		if err != nil {
			return err
		}
	} else {
		_, err = companyRepo.Insert(newCompany)
		if err != nil {
			return err
		}
	}
	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
}

func (srv CompanyServices) setCompanyCharge(param *command.SetCompanyCharge) 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()
	}()

	companyRepo := factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, companyList, err := companyRepo.Find(map[string]interface{}{
		"id":    param.CompanyId,
		"limit": 1,
	})

	if err != nil {
		return err
	}
	for i := range companyList {
		companyList[i].ChargeUserIds = param.ChargeUserIds
		companyList[i].UpdateAt = time.Now()
		_, err = companyRepo.Update(companyList[i])
		if err != nil {
			return err
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

//changeAdmin
//从BusinessAdmins 接收消息 变更主管
func (srv CompanyServices) changeAdmin(param *command.ChangeAdminCommand) 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":     10,
		"companyId": param.CompanyId,
		"adminType": domain.UserTypeManager,
	})
	if err != nil {
		return err
	}
	//修改旧管理员 为普通用户
	for i := range userList {
		userList[i].AdminType = domain.UserTypeCommon
		userList[i].UpdateAt = time.Now()
		_, err := userRepo.Update(userList[i])
		if err != nil {
			return err
		}
	}
	//获取新管理员
	_, userList2, err := userRepo.Find(map[string]interface{}{
		"limit":     1,
		"companyId": param.CompanyId,
		"account":   param.UserAccount,
	})
	if err != nil {
		return err
	}
	//修改为管理员用户
	for i := range userList2 {
		userList[i].AdminType = domain.UserTypeManager
		userList[i].UpdateAt = time.Now()
		_, err := userRepo.Update(userList[i])
		if err != nil {
			return err
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}