package company

import (
	"encoding/json"
	"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"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/log"
)

type SyncDataCompanyService struct {
}

// type BusinessAdminCommand struct {
// 	//company:公司
// 	Module string `json:"module"`
// 	// add:添加,edit:编辑,setCompanyCharge：更改公司主管,changeAdmin换管理员
// 	Action string `json:"action"`
// 	// 具体的对象JSON数据
// 	Datas json.RawMessage `json:"data"`
// }

//从BusinessAdmins 接收消息，变更公司数据
func (c SyncDataCompanyService) FromBusinessAdmin(param *domain.MessageBody) error {
	action := param.Module + "/" + param.Action
	var err error
	switch action {
	case "company/add":
		var param1 command.SaveCompanyCommand
		err = json.Unmarshal(param.Datas, &param1)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = c.addCompany(&param1)
	case "company/edit":
		var param2 command.SaveCompanyCommand
		err = json.Unmarshal(param.Datas, &param2)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = c.editCompany(&param2)
	case "company/setCompanyCharge":
		var param3 command.SetCompanyCharge
		err = json.Unmarshal(param.Datas, &param3)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = c.setCompanyCharge(&param3)
	case "company/changeAdmin":
		var param3 command.ChangeAdminCommand
		err = json.Unmarshal(param.Datas, &param3)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		err = c.changeAdmin(&param3)
	default:
		log.Logger.Error("action err:" + action)
	}

	return err
}

//addCompany
//从BusinessAdmins 接收消息 添加公司
//module="company" action="add"
func (c SyncDataCompanyService) 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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, 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
}

//editCompany
//从BusinessAdmins 接收消息 更新公司
//module="company" action="edit"
func (c SyncDataCompanyService) 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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, userList, err := userRepo.Find(map[string]interface{}{
		"limit": 1,
		"id":    param.User.Id,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	} else {
		_, err = companyRepo.Insert(newCompany)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	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
}

//module="company" action="setCompanyCharge"
func (srv SyncDataCompanyService) 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 application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range companyList {
		companyList[i].ChargeUserIds = param.ChargeUserIds
		companyList[i].UpdateAt = time.Now()
		_, err = companyRepo.Update(companyList[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
}

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