package logic

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

	"github.com/google/uuid"
)

type membersLogic struct{}

var MembersLogic = new(membersLogic)

func (membersLogic) AddMember(req *members.AddMemberReq) (result *members.AddMemberResp, err error) {
	result = &members.AddMemberResp{}
	if req.Uuid == "" {
		req.Uuid = uuid.New().String()
	}
	if req.Name == "" {
		return nil, errors.New("姓名不能为空")
	}
	err = dao.MembersDao.AddMember(req)
	if err != nil {
		return nil, err
	}
	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, err
	}
	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, err
	}
	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)

	result.Data = make([]*members.Member, len(data))
	for i, member := range data {
		result.Data[i] = &members.Member{
			Uuid:         member.Uuid,
			Name:         member.Name,
			Brief:        member.Brief,
			Introduction: member.Introduction,
			Sort:         member.Sort,
			UpdatedAt:    member.UpdatedAt.Format("2006-01-02 15:04:05"),
			Operator:     member.Operator,
		}
	}

	if len(result.Data) > 0 {
		// 收集所有UUID
		uuids := make([]string, len(result.Data))
		for i, member := range result.Data {
			uuids[i] = member.Uuid
		}

		// 批量查询所有关联数据
		managementMap, err := dao.MembersDao.GetManagementByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询成员管理失败")
		}

		boardOfDirectorsMap, err := dao.MembersDao.GetBoardOfDirectorsByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询董事会失败")
		}

		committeeAppointmentsMap, err := dao.MembersDao.GetCommitteeAppointmentsByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询委员会失败")
		}

		// 批量赋值
		for _, member := range result.Data {
			if management, exists := managementMap[member.Uuid]; exists {
				member.Management = &members.Management{
					Name:         management.Name,
					Image:        management.Image,
					Brief:        management.Brief,
					Introduction: management.Introduction,
					Status:       management.Status,
					IsSetting:    management.IsSetting,
				}
			}

			if boardOfDirectors, exists := boardOfDirectorsMap[member.Uuid]; exists {
				member.BoardOfDirectors = &members.BoardOfDirectors{
					Name:         boardOfDirectors.Name,
					Status:       boardOfDirectors.Status,
					Brief:        boardOfDirectors.Brief,
					Introduction: boardOfDirectors.Introduction,
					IsSetting:    boardOfDirectors.IsSetting,
				}
			}

			if committeeAppointments, exists := committeeAppointmentsMap[member.Uuid]; exists {
				member.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, err
	}
	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, err
	}
	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, err
	}
	result.Msg = "编辑委员会成功"
	return result, nil
}