package menu

import (
	"context"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/model/entity"
	"server/internal/service"
	"server/utility/ecode"
)

type sMenu struct {
}

func New() service.IMenu {
	return &sMenu{}
}

func init() {
	service.RegisterMenu(New())
}

// Create 创建菜单
func (s *sMenu) Create(ctx context.Context, in *model.MenuCreateInput) (out *model.CreateOut, err error) {
	// 检查菜单名称是否已存在
	exist, err := dao.Menus.Ctx(ctx).Where(do.Menus{Name: in.Name}).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("插入菜单查重出现异常")
	}
	if exist {
		return nil, ecode.Params.Sub("菜单名称已存在")
	}

	id, err := dao.Menus.Ctx(ctx).InsertAndGetId(do.Menus{
		ParentId:  in.ParentId,
		Name:      in.Name,
		Path:      in.Path,
		Component: in.Component,
		Type:      in.Type,
		Icon:      in.Icon,
		Sort:      in.Sort,
		Hidden:    in.Hidden,
		Status:    in.Status,
	})
	if err != nil {
		return nil, err
	}

	return &model.CreateOut{Id: id}, nil
}

// Delete 删除菜单
func (s *sMenu) Delete(ctx context.Context, in *model.MenuDeleteInput) (out *model.DeleteOut, err error) {
	// 检查是否存在子菜单
	count, err := dao.Menus.Ctx(ctx).Where(do.Menus{ParentId: in.Id}).Count()
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return nil, ecode.Params.Sub("存在子菜单，请先删除子菜单")
	}

	// 删除菜单
	_, err = dao.Menus.Ctx(ctx).Where(do.Menus{Id: in.Id}).Delete()
	if err != nil {
		return nil, err
	}
	return &model.DeleteOut{}, nil
}

// BatchDelete 批量删除菜单
func (s *sMenu) BatchDelete(ctx context.Context, in *model.BatchDeleteIn) (out *model.BatchDeleteOut, err error) {
	// 检查是否存在子菜单
	var menus []*entity.Menus
	err = dao.Menus.Ctx(ctx).WhereIn(dao.Menus.Columns().ParentId, in.Ids).Scan(&menus)
	if err != nil {
		return nil, err
	}

	// 获取有子菜单的ID
	hasChildrenIds := make(map[int]bool)
	for _, menu := range menus {
		hasChildrenIds[int(menu.ParentId)] = true
	}

	// 找出可以删除的ID
	var deletableIds []int
	var undeletableIds []int
	for _, id := range in.Ids {
		if hasChildrenIds[id] {
			undeletableIds = append(undeletableIds, id)
		} else {
			deletableIds = append(deletableIds, id)
		}
	}

	// 如果有可删除的ID，执行删除操作
	if len(deletableIds) > 0 {
		_, err = dao.Menus.Ctx(ctx).WhereIn(dao.Menus.Columns().Id, deletableIds).Delete()
		if err != nil {
			return nil, err
		}
	}

	return &model.BatchDeleteOut{
		Ids: undeletableIds,
	}, nil
}

// Update 更新菜单
func (s *sMenu) Update(ctx context.Context, in *model.MenuUpdateInput) (out *model.UpdateOut, err error) {
	// 检查菜单是否存在
	exist, err := dao.Menus.Ctx(ctx).WherePri(in.Id).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询菜单失败")
	}
	if !exist {
		return nil, ecode.Params.Sub("菜单不存在")
	}
	exist, err = dao.Menus.Ctx(ctx).Where(do.Menus{Name: in.Name}).WhereNot(dao.Menus.Columns().Id, in.Id).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询菜单失败")
	}
	if exist {
		return nil, ecode.Params.Sub("菜单名称已存在")
	}

	// 更新菜单
	_, err = dao.Menus.Ctx(ctx).Where(do.Menus{
		Id: in.Id,
	}).Update(do.Menus{
		ParentId:  in.ParentId,
		Name:      in.Name,
		Path:      in.Path,
		Component: in.Component,
		Type:      in.Type,
		Icon:      in.Icon,
		Sort:      in.Sort,
		Hidden:    in.Hidden,
		Status:    in.Status,
	})
	if err != nil {
		return nil, err
	}

	return &model.UpdateOut{}, nil
}

// List 获取菜单列表
func (s *sMenu) List(ctx context.Context, in *model.MenuListInput) (out *model.MenuListOutput, err error) {
	m := dao.Menus.Ctx(ctx)

	// 构建查询条件
	if in.ParentId > 0 {
		m = m.Where(do.Menus{
			ParentId: in.ParentId,
		})
	}
	if in.Name != "" {
		m = m.WhereLike(dao.Menus.Columns().Name, "%"+in.Name+"%")
	}
	if in.Path != "" {
		m = m.WhereLike(dao.Menus.Columns().Path, "%"+in.Path+"%")
	}
	if in.Type > 0 {
		m = m.Where(do.Menus{
			Type: in.Type,
		})
	}
	if in.Status > 0 {
		m = m.Where(do.Menus{
			Status: in.Status,
		})
	}

	// 分页查询
	list := make([]model.Menu, 0)
	var total int
	err = m.Page(in.Page, in.Size).OrderAsc(dao.Menus.Columns().Sort).ScanAndCount(&list, &total, false)
	if err != nil {
		return nil, err
	}

	return &model.MenuListOutput{
		List:  list,
		Total: total,
	}, nil
}