package service

import (
	"fmt"
	"gofaster/internal/auth/model"
	"gofaster/internal/auth/repository"

	"go.uber.org/zap"
)

// MenuRouteService 菜单路由关联表服务
type MenuRouteService struct {
	menuRouteRepo *repository.MenuRouteRepository
	menuRepo      *repository.MenuRepository
	routeRepo     *repository.RouteMappingRepository
	log           *zap.Logger
}

// NewMenuRouteService 创建菜单路由关联表服务
func NewMenuRouteService(
	menuRouteRepo *repository.MenuRouteRepository,
	menuRepo *repository.MenuRepository,
	routeRepo *repository.RouteMappingRepository,
	log *zap.Logger,
) *MenuRouteService {
	return &MenuRouteService{
		menuRouteRepo: menuRouteRepo,
		menuRepo:      menuRepo,
		routeRepo:     routeRepo,
		log:           log,
	}
}

// CreateMenuRoute 创建菜单路由关联
func (s *MenuRouteService) CreateMenuRoute(menuRoute *model.MenuRoute) error {
	// 验证菜单是否存在
	if _, err := s.menuRepo.FindByID(menuRoute.MenuID); err != nil {
		return fmt.Errorf("菜单不存在")
	}

	// 验证路由映射是否存在
	if _, err := s.routeRepo.FindByID(menuRoute.RouteMappingID); err != nil {
		return fmt.Errorf("路由映射不存在")
	}

	// 检查关联是否已存在
	if existing, err := s.menuRouteRepo.GetByMenuAndRoute(menuRoute.MenuID, menuRoute.RouteMappingID); err == nil && existing != nil {
		return fmt.Errorf("菜单路由关联已存在")
	}

	return s.menuRouteRepo.Create(menuRoute)
}

// CreateMenuRoutes 批量创建菜单路由关联
func (s *MenuRouteService) CreateMenuRoutes(menuID uint, routeMappingIDs []uint) error {
	// 验证菜单是否存在
	if _, err := s.menuRepo.FindByID(menuID); err != nil {
		return fmt.Errorf("菜单不存在")
	}

	// 验证所有路由映射是否存在
	for _, routeID := range routeMappingIDs {
		if _, err := s.routeRepo.FindByID(routeID); err != nil {
			return fmt.Errorf("路由映射不存在")
		}
	}

	// 删除现有关联
	if err := s.menuRouteRepo.DeleteByMenuID(menuID); err != nil {
		return err
	}

	// 创建新关联
	var menuRoutes []*model.MenuRoute
	for i, routeID := range routeMappingIDs {
		menuRoute := &model.MenuRoute{
			MenuID:         menuID,
			RouteMappingID: routeID,
			Sort:           i,
			IsDefault:      i == 0, // 第一个设为默认
			Status:         1,
		}
		menuRoutes = append(menuRoutes, menuRoute)
	}

	return s.menuRouteRepo.CreateBatch(menuRoutes)
}

// GetMenuRoutes 获取菜单的路由关联
func (s *MenuRouteService) GetMenuRoutes(menuID uint) ([]*model.MenuRoute, error) {
	return s.menuRouteRepo.GetByMenuID(menuID)
}

// GetRouteMenus 获取路由的菜单关联
func (s *MenuRouteService) GetRouteMenus(routeMappingID uint) ([]*model.MenuRoute, error) {
	return s.menuRouteRepo.GetByRouteMappingID(routeMappingID)
}

// GetMenuWithRoutes 获取菜单及其关联的路由信息
func (s *MenuRouteService) GetMenuWithRoutes(menuID uint) (*model.Menu, []*model.RouteMapping, error) {
	return s.menuRouteRepo.GetMenuWithRoutes(menuID)
}

// GetRouteWithMenus 获取路由及其关联的菜单信息
func (s *MenuRouteService) GetRouteWithMenus(routeMappingID uint) (*model.RouteMapping, []*model.Menu, error) {
	return s.menuRouteRepo.GetRouteWithMenus(routeMappingID)
}

// UpdateMenuRoute 更新菜单路由关联
func (s *MenuRouteService) UpdateMenuRoute(menuRoute *model.MenuRoute) error {
	// 验证关联是否存在
	if _, err := s.menuRouteRepo.GetByID(menuRoute.ID); err != nil {
		return fmt.Errorf("菜单路由关联不存在")
	}

	return s.menuRouteRepo.Update(menuRoute)
}

// DeleteMenuRoute 删除菜单路由关联
func (s *MenuRouteService) DeleteMenuRoute(id uint) error {
	return s.menuRouteRepo.Delete(id)
}

// DeleteMenuRoutes 删除菜单的所有路由关联
func (s *MenuRouteService) DeleteMenuRoutes(menuID uint) error {
	return s.menuRouteRepo.DeleteByMenuID(menuID)
}

// DeleteRouteMenus 删除路由的所有菜单关联
func (s *MenuRouteService) DeleteRouteMenus(routeMappingID uint) error {
	return s.menuRouteRepo.DeleteByRouteMappingID(routeMappingID)
}

// DeleteMenuRouteByMenuAndRoute 根据菜单ID和路由ID删除关联
func (s *MenuRouteService) DeleteMenuRouteByMenuAndRoute(menuID, routeMappingID uint) error {
	return s.menuRouteRepo.DeleteByMenuAndRoute(menuID, routeMappingID)
}

// ListMenuRoutes 获取菜单路由关联列表
func (s *MenuRouteService) ListMenuRoutes(page, pageSize int) ([]*model.MenuRoute, int64, error) {
	return s.menuRouteRepo.List(page, pageSize)
}

// SyncMenuRoutes 同步菜单路由关联（用于批量操作）
func (s *MenuRouteService) SyncMenuRoutes(menuID uint, routeMappingIDs []uint) error {
	s.log.Info("开始同步菜单路由关联", zap.Uint("menuID", menuID), zap.Any("routeMappingIDs", routeMappingIDs))

	// 删除现有关联
	if err := s.menuRouteRepo.DeleteByMenuID(menuID); err != nil {
		s.log.Error("删除现有菜单路由关联失败", zap.Error(err))
		return err
	}

	// 如果没有新的路由映射，直接返回
	if len(routeMappingIDs) == 0 {
		s.log.Info("没有新的路由映射，同步完成")
		return nil
	}

	// 创建新关联
	var menuRoutes []*model.MenuRoute
	for i, routeID := range routeMappingIDs {
		menuRoute := &model.MenuRoute{
			MenuID:         menuID,
			RouteMappingID: routeID,
			Sort:           i,
			IsDefault:      i == 0, // 第一个设为默认
			Status:         1,
		}
		menuRoutes = append(menuRoutes, menuRoute)
	}

	if err := s.menuRouteRepo.CreateBatch(menuRoutes); err != nil {
		s.log.Error("创建菜单路由关联失败", zap.Error(err))
		return err
	}

	s.log.Info("菜单路由关联同步完成", zap.Int("关联数量", len(menuRoutes)))
	return nil
}