package logic

import (
	"errors"
	"micro-document/api/members"
	"micro-document/internel/dao"
	util "micro-document/pkg/utils"

	"github.com/jinzhu/copier"
)

type membersLogic struct{}

var MembersLogic = new(membersLogic)

func (membersLogic) AddMember(req *members.AddMemberReq) (result *members.AddMemberResp, err error) {
	result = &members.AddMemberResp{}
	if req.Name == "" {
		return nil, errors.New("姓名不能为空")
	}
	err = dao.MembersDao.AddMember(req)
	if err != nil {
		return nil, errors.New("新增成员失败")
	}
	result.Msg = "新增成员成功"
	return nil, nil
}

func (membersLogic) EditMember(req *members.EditMemberReq) (result *members.EditMemberResp, err error) {
	result = &members.EditMemberResp{}
	err = dao.MembersDao.EditMember(req)
	if err != nil {
		return nil, errors.New("编辑成员失败")
	}
	result.Msg = "编辑成员成功"
	return nil, nil
}

func (membersLogic) DeleteMember(req *members.DeleteMemberReq) (result *members.DeleteMemberResp, err error) {
	result = &members.DeleteMemberResp{}
	err = dao.MembersDao.DeleteMember(req)
	if err != nil {
		return nil, errors.New("删除成员失败")
	}
	result.Msg = "删除成员成功"
	return nil, nil
}

func (membersLogic) GetMemberList(req *members.GetMemberListReq) (result *members.GetMemberListResp, err error) {
	result = &members.GetMemberListResp{
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	data, total, err := dao.MembersDao.GetMemberList(req)
	if err != nil {
		return nil, errors.New("查询成员列表失败")
	}
	//查询获取成员管理，董事会，委员会信息
	result.Total = int32(total)

	if err = copier.CopyWithOption(&result.Data, &data, util.CopierProtoOptions); err != nil {
		return nil, errors.New("复制成员列表失败")
	}
	for _, v := range result.Data {
		management, err := dao.MembersDao.GetManagementByUuid(v.Uuid)
		if err != nil {
			return nil, errors.New("查询成员管理失败")
		}
		v.Management = &members.Management{
			Name:         management.Name,
			Image:        management.Image,
			Brief:        management.Brief,
			Introduction: management.Introduction,
			Status:       management.Status,
			IsSetting:    management.IsSetting,
		}

		boardOfDirectors, err := dao.MembersDao.GetBoardOfDirectorsByUuid(v.Uuid)
		if err != nil {
			return nil, errors.New("查询董事会失败")
		}
		v.BoardOfDirectors = &members.BoardOfDirectors{
			Name:         boardOfDirectors.Name,
			Status:       boardOfDirectors.Status,
			Brief:        boardOfDirectors.Brief,
			Introduction: boardOfDirectors.Introduction,
			IsSetting:    boardOfDirectors.IsSetting,
		}

		committeeAppointments, err := dao.MembersDao.GetCommitteeAppointmentsByUuid(v.Uuid)
		if err != nil {
			return nil, errors.New("查询委员会失败")
		}
		v.CommitteeAppointments = &members.CommitteeAppointments{
			Name:                  committeeAppointments.Name,
			Status:                committeeAppointments.Status,
			AuditCommittee:        committeeAppointments.AuditCommittee,
			CompensationCommittee: committeeAppointments.CompensationCommittee,
			NominatingCommittee:   committeeAppointments.NominatingCommittee,
			IsSetting:             committeeAppointments.IsSetting,
		}
	}
	return result, nil
}

// 编辑成员管理
func (membersLogic) EditManagement(req *members.EditManagementReq) (result *members.EditManagementResp, err error) {
	result = &members.EditManagementResp{}
	err = dao.MembersDao.EditManagement(req)
	if err != nil {
		return nil, errors.New("编辑成员管理失败")
	}
	result.Msg = "编辑成员管理成功"
	return result, nil
}

// 编辑董事会
func (membersLogic) EditBoardOfDirectors(req *members.EditBoardOfDirectorsReq) (result *members.EditBoardOfDirectorsResp, err error) {
	result = &members.EditBoardOfDirectorsResp{}
	err = dao.MembersDao.EditBoardOfDirectors(req)
	if err != nil {
		return nil, errors.New("编辑董事会失败")
	}
	result.Msg = "编辑董事会成功"
	return result, nil
}

// 编辑委员会
func (membersLogic) EditCommitteeAppointments(req *members.EditCommitteeAppointmentsReq) (result *members.EditCommitteeAppointmentsResp, err error) {
	result = &members.EditCommitteeAppointmentsResp{}
	err = dao.MembersDao.EditCommitteeAppointments(req)
	if err != nil {
		return nil, errors.New("编辑委员会失败")
	}
	result.Msg = "编辑委员会成功"
	return result, nil
}