package service

import (
	"IotAdmin/common/global"
	"IotAdmin/core/sdk/config"
	"IotAdmin/core/tools/utils"
	"fmt"
	"sort"
	"strings"

	"IotAdmin/core/sdk/pkg"

	"github.com/pkg/errors"
	"gorm.io/gorm"

	"IotAdmin/app/system/models"
	"IotAdmin/app/system/service/dto"
	cDto "IotAdmin/common/dto"
	"IotAdmin/core/sdk/service"
)

type SysMenuService struct {
	service.Service
}

// GetPage 获取SysMenu列表
func (e *SysMenuService) GetPage(c *dto.SysMenuGetPageReq, menus *[]models.SysMenu) *SysMenuService {
	var menu = make([]models.SysMenu, 0)
	err := e.getPage(c, &menu).Error
	if err != nil {
		_ = e.AddError(err)
		return e
	}
	for i := 0; i < len(menu); i++ {
		if menu[i].ParentId != 0 {
			continue
		}
		menusInfo := menuCall(&menu, menu[i])
		*menus = append(*menus, menusInfo)
	}
	return e
}

// getPage 菜单分页列表
func (e *SysMenuService) getPage(c *dto.SysMenuGetPageReq, list *[]models.SysMenu) *SysMenuService {
	var err error
	var data models.SysMenu

	err = e.Orm.Model(&data).
		Scopes(
			cDto.OrderDest("sort", false),
			cDto.MakeCondition(c.GetNeedSearch()),
		).Preload("SysApi").
		Find(list).Error
	if err != nil {
		e.Log.Errorf("getSysMenuPage error:%s", err)
		_ = e.AddError(err)
		return e
	}
	return e
}

// Get 获取SysMenu对象
func (e *SysMenuService) Get(d *dto.SysMenuGetReq, model *models.SysMenu) *SysMenuService {
	var err error
	var data models.SysMenu

	db := e.Orm.Model(&data).Preload("SysApi").
		First(model, d.GetId())
	err = db.Error
	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
		err = errors.New("查看对象不存在或无权查看")
		e.Log.Errorf("GetSysMenu error:%s", err)
		_ = e.AddError(err)
		return e
	}
	if err != nil {
		e.Log.Errorf("db error:%s", err)
		_ = e.AddError(err)
		return e
	}
	apis := make([]int, 0)
	for _, v := range model.SysApi {
		apis = append(apis, v.Id)
	}
	model.Apis = apis
	return e
}

// Insert 创建SysMenu对象
func (e *SysMenuService) Insert(c *dto.SysMenuInsertReq) *SysMenuService {
	var err error
	var data models.SysMenu
	c.Generate(&data)
	tx := e.Orm.Debug().Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	err = tx.Where("id in ?", c.Apis).Find(&data.SysApi).Error
	if err != nil {
		tx.Rollback()
		e.Log.Errorf("db error:%s", err)
		_ = e.AddError(err)
	}
	err = tx.Create(&data).Error
	if err != nil {
		tx.Rollback()
		e.Log.Errorf("db error:%s", err)
		_ = e.AddError(err)
	}
	c.MenuId = data.MenuId
	err = e.InIitPaths(tx, &data)
	if err != nil {
		tx.Rollback()
		e.Log.Errorf("db error:%s", err)
		_ = e.AddError(err)
	}
	tx.Commit()
	return e
}

func (e *SysMenuService) InIitPaths(tx *gorm.DB, menu *models.SysMenu) error {
	var err error
	var data models.SysMenu
	parentMenu := new(models.SysMenu)
	if menu.ParentId != 0 {
		err = tx.Model(&data).First(parentMenu, menu.ParentId).Error
		if err != nil {
			return err
		}
		if parentMenu.Paths == "" {
			err = errors.New("父级paths异常，请尝试对当前节点父级菜单进行更新操作！")
			return err
		}
		menu.Paths = parentMenu.Paths + "/" + pkg.IntToString(menu.MenuId)
	} else {
		menu.Paths = "/0/" + pkg.IntToString(menu.MenuId)
	}
	err = tx.Model(&data).Where("menu_id = ?", menu.MenuId).Update("paths", menu.Paths).Error
	return err
}

// Update 修改SysMenu对象
func (e *SysMenuService) Update(c *dto.SysMenuUpdateReq) *SysMenuService {
	var err error
	tx := e.Orm.Debug().Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	var aList = make([]models.SysApi, 0)
	var model = models.SysMenu{}
	tx.Preload("SysApi").First(&model, c.GetId())
	oldPath := model.Paths
	tx.Where("id in ?", c.Apis).Find(&aList)
	err = tx.Model(&model).Association("SysApi").Delete(model.SysApi)
	if err != nil {
		e.Log.Errorf("delete policy error:%s", err)
		_ = e.AddError(err)
		return e
	}
	c.Generate(&model)
	model.SysApi = aList
	db := tx.Model(&model).Session(&gorm.Session{FullSaveAssociations: true}).Debug().Save(&model)
	if err = db.Error; err != nil {
		e.Log.Errorf("db error:%s", err)
		_ = e.AddError(err)
		return e
	}
	if db.RowsAffected == 0 {
		_ = e.AddError(errors.New("无权更新该数据"))
		return e
	}
	var menuList []models.SysMenu
	tx.Where("paths like ?", oldPath+"%").Find(&menuList)
	for _, v := range menuList {
		v.Paths = strings.Replace(v.Paths, oldPath, model.Paths, 1)
		tx.Model(&v).Update("paths", v.Paths)
	}
	return e
}

// Remove 删除SysMenu
func (e *SysMenuService) Remove(d *dto.SysMenuDeleteReq) *SysMenuService {
	var err error
	var data models.SysMenu

	db := e.Orm.Model(&data).Delete(&data, d.Ids)
	if err = db.Error; err != nil {
		err = db.Error
		e.Log.Errorf("Delete error: %s", err)
		_ = e.AddError(err)
	}
	if db.RowsAffected == 0 {
		err = errors.New("无权删除该数据")
		_ = e.AddError(err)
	}
	return e
}

// GetList 获取菜单数据
func (e *SysMenuService) GetList(c *dto.SysMenuGetPageReq, list *[]models.SysMenu) error {
	var err error
	var data models.SysMenu

	err = e.Orm.Model(&data).
		Scopes(
			cDto.MakeCondition(c.GetNeedSearch()),
		).
		Find(list).Error
	if err != nil {
		e.Log.Errorf("db error:%s", err)
		return err
	}
	return nil
}

// SetLabel 修改角色中 设置菜单基础数据
func (e *SysMenuService) SetLabel() (m []dto.MenuLabel, err error) {
	var list []models.SysMenu
	err = e.GetList(&dto.SysMenuGetPageReq{}, &list)

	m = make([]dto.MenuLabel, 0)
	for i := 0; i < len(list); i++ {
		if list[i].ParentId != 0 {
			continue
		}
		e := dto.MenuLabel{}
		e.Id = list[i].MenuId
		e.Label = list[i].MenuName
		orgsInfo := menuLabelCall(&list, e)

		m = append(m, orgsInfo)
	}
	return
}

// GetSysMenuByRoleName 左侧菜单
func (e *SysMenuService) GetSysMenuByRoleName(roleName ...string) ([]models.SysMenu, error) {
	var MenuList []models.SysMenu
	var role models.SysRole
	var err error
	admin := false
	for _, s := range roleName {
		if s == "admin" {
			admin = true
		}
	}

	if len(roleName) > 0 && admin {
		var data []models.SysMenu
		err = e.Orm.Where(" menu_type in ('M','C')").
			Order("sort").
			Find(&data).
			Error
		MenuList = data
	} else {
		err = e.Orm.Model(&role).Preload("Menus", func(db *gorm.DB) *gorm.DB {
			return db.Where(" menu_type in ('M','C')").Order("sort")
		}).Where("role_name in ?", roleName).Find(&role).
			Error
		MenuList = *role.Menus
	}

	if err != nil {
		e.Log.Errorf("db error:%s", err)
	}
	return MenuList, err
}

// GetBtnChildrenByPerm 根据权限获取按钮菜单
func (e *SysMenuService) GetBtnChildrenByPerm(permission string) ([]models.SysMenu, error) {
	var (
		//menu     models.Menus
		menuList []models.SysMenu
	)
	err := e.Orm.Model(&menuList).Where("parent_id = (?) AND is_hide = 0 AND menu_type = ?", e.Orm.Table("sys_menu").Select("menu_id").Where("permission = ?", permission), global.Button).Find(&menuList).Error
	if err != nil {
		e.Log.Errorf("db error:%s", err)
		return nil, err
	}
	return menuList, err
}

// menuLabelCall 递归构造组织数据
func menuLabelCall(eList *[]models.SysMenu, org dto.MenuLabel) dto.MenuLabel {
	list := *eList

	menuLabels := make([]dto.MenuLabel, 0)
	for j := 0; j < len(list); j++ {

		if org.Id != list[j].ParentId {
			continue
		}
		mi := dto.MenuLabel{}
		mi.Id = list[j].MenuId
		mi.Label = list[j].MenuName
		mi.Children = []dto.MenuLabel{}
		if list[j].MenuType != "F" {
			ms := menuLabelCall(eList, mi)
			menuLabels = append(menuLabels, ms)
		} else {
			menuLabels = append(menuLabels, mi)
		}
	}
	if len(menuLabels) > 0 {
		org.Children = menuLabels
	} else {
		org.Children = nil
	}
	return org
}

// menuCall 构建菜单树
func menuCall(menuList *[]models.SysMenu, menu models.SysMenu) models.SysMenu {
	list := *menuList

	menus := make([]models.SysMenu, 0)
	for j := 0; j < len(list); j++ {

		if menu.MenuId != list[j].ParentId || list[j].IsHide {
			continue
		}
		mi := models.SysMenu{}
		mi.MenuId = list[j].MenuId
		mi.Path = list[j].Path
		mi.MenuName = list[j].MenuName
		mi.Icon = list[j].Icon
		//mi.Path = list[j].Path
		mi.MenuType = list[j].MenuType
		mi.Action = list[j].Action
		mi.Permission = list[j].Permission
		mi.ParentId = list[j].ParentId
		mi.NoCache = list[j].NoCache
		//mi.Breadcrumb = list[j].Breadcrumb
		mi.Component = list[j].Component
		mi.BtnClass = list[j].BtnClass
		mi.BtnScript = list[j].BtnScript
		mi.Sort = list[j].Sort
		mi.IsHide = list[j].IsHide
		mi.IsFrame = list[j].IsFrame
		mi.CreatedAt = list[j].CreatedAt
		mi.SysApi = list[j].SysApi
		mi.Children = []models.SysMenu{}

		if mi.MenuType != global.Button {
			ms := menuCall(menuList, mi)
			menus = append(menus, ms)
		} else {
			menus = append(menus, mi)
		}
	}
	menu.Children = menus
	return menu
}

func menuDistinct(menuList []models.SysMenu) (result []models.SysMenu) {
	distinctMap := make(map[int]struct{}, len(menuList))
	for _, menu := range menuList {
		if _, ok := distinctMap[menu.MenuId]; !ok {
			distinctMap[menu.MenuId] = struct{}{}
			result = append(result, menu)
		}
	}
	return result
}

func recursiveSetMenu(orm *gorm.DB, mIds []int, menus *[]models.SysMenu) error {
	if len(mIds) == 0 || menus == nil {
		return nil
	}
	var subMenus []models.SysMenu
	err := orm.Where(fmt.Sprintf(" menu_type in ('%s', '%s', '%s') and menu_id in ?",
		global.Directory, global.Menu, global.Button), mIds).Order("menu_type").Order("sort").Find(&subMenus).Error
	if err != nil {
		return err
	}

	subIds := make([]int, 0)
	for _, menu := range subMenus {
		if menu.ParentId != 0 {
			subIds = append(subIds, menu.ParentId)
		}
		if menu.MenuType != global.Button {
			*menus = append(*menus, menu)
		}
	}
	return recursiveSetMenu(orm, subIds, menus)
}

// GetMenuRouter 获取左侧菜单路由
func (e *SysMenuService) GetMenuRouter(roleName string) (result []dto.SysRouterVo, err error) {
	menus, err := e.getByRoleName(roleName)
	if err != nil {
		return
	}
	menus = buildMenuTree(menus)
	result = buildRouters(menus)
	return
}
func buildMenuTree(menus []models.SysMenu) (m []models.SysMenu) {
	m = make([]models.SysMenu, 0)
	for i := 0; i < len(menus); i++ {
		menu := menus[i]
		if menu.ParentId != 0 {
			continue
		}
		menusInfo := menuCall(&menus, menus[i])
		m = append(m, menusInfo)
	}
	return
}
func buildRouters(menus []models.SysMenu) []dto.SysRouterVo {
	voList := make([]dto.SysRouterVo, 0)
	for i := 0; i < len(menus); i++ {
		menu := menus[i]
		if config.ApplicationConfig.Mode != "dev" && menu.Path == "dev-tools" {
			continue
		}
		if menu.MenuType == global.Button {
			continue
		}
		routerVo := &dto.SysRouterVo{}
		routerVo.Generate(&menu)
		routerVo.Component = getComponent(menu)
		routerVo.Path = getRouterPath(menu)
		if len(menu.Children) > 0 && menu.MenuType == global.Directory {
			routerVo.AlwaysShow = true
			routerVo.Redirect = "noRedirect"
			routerVo.Children = buildRouters(menu.Children)
		} else if isMenuFrame(menu) {
			routerVo.Meta = dto.SysRouterMetaVo{}
			child := &dto.SysRouterVo{}
			child.Generate(&menu)
			child.Hidden = false
			routerVo.Children = append(routerVo.Children, *child)
		} else if menu.ParentId == 0 && isInnerLink(menu) {
			routerVo.Path = "/"
			child := &dto.SysRouterVo{}
			child.Generate(&menu)
			child.Hidden = false
			child.Component = ""
			routerVo.Children = append(routerVo.Children, *child)
		}
		voList = append(voList, *routerVo)
	}
	return voList
}

func getRouterPath(menu models.SysMenu) string {
	routerPath := menu.Path
	// 内链打开外网方式
	if menu.ParentId != 0 && isInnerLink(menu) {
		routerPath = strings.Replace(routerPath, "http://", "", 1)
		routerPath = strings.Replace(routerPath, "https://", "", 1)
		routerPath = strings.Replace(routerPath, "www", "", 1)
		routerPath = strings.Replace(routerPath, ".", "/", 1)
	}
	// 非外链并且是一级目录（类型为目录）
	if menu.ParentId == 0 && menu.MenuType == global.Directory && !menu.IsFrame {
		routerPath = "/" + menu.Path
	} else if isMenuFrame(menu) {
		// 非外链并且是一级目录（类型为菜单）
		routerPath = "/"
	}
	return routerPath
}
func getComponent(menu models.SysMenu) string {
	component := dto.LAYOUT
	if menu.Component != "" && !isMenuFrame(menu) {
		component = menu.Component
	} else if menu.Component == "" && menu.ParentId != 0 && isInnerLink(menu) {
		component = dto.INNER_LINK
	} else if menu.Component == "" && isParentView(menu) {
		component = dto.PARENT_VIEW
	}
	return component
}

func isInnerLink(menu models.SysMenu) bool {
	return !menu.IsFrame && utils.HasPrefix(&menu.Path, "http")
}
func isParentView(menu models.SysMenu) bool {
	return menu.ParentId == 0 && menu.MenuType == global.Directory
}
func isMenuFrame(menu models.SysMenu) bool {
	return menu.ParentId == 0 && menu.MenuType == global.Menu && menu.IsFrame
}

func (e *SysMenuService) getByRoleName(roleName string) ([]models.SysMenu, error) {
	var role models.SysRole
	var err error
	data := make([]models.SysMenu, 0)

	if roleName == "admin" {
		err = e.Orm.Where(" menu_type in ('M','C') and deleted_at is null").
			Order("sort").
			Find(&data).
			Error
		err = errors.WithStack(err)
	} else {
		role.RoleKey = roleName
		err = e.Orm.Model(&role).Where("role_key = ? ", roleName).Preload("Menus").First(&role).Error

		if role.Menus != nil {
			mIds := make([]int, 0)
			for _, menu := range *role.Menus {
				mIds = append(mIds, menu.MenuId)
			}
			if err := recursiveSetMenu(e.Orm, mIds, &data); err != nil {
				return nil, err
			}

			data = menuDistinct(data)
		}
	}

	sort.Sort(models.SysMenuSlice(data))
	return data, err
}