package cms

import (
	"fmt"
	"strings"
	"time"

	"git.rosy.net.cn/jx-callback/business/jxutils"

	"git.rosy.net.cn/baseapi/utils"

	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
)

func GetMenu(ctx *jxcontext.Context, userID string) (menus []*model.Menu, err error) {
	if userID == "" {
		return dao.GetMenu(dao.GetDB(), "", 0, userID)
	} else {
		if user, err := dao.GetUserByID(dao.GetDB(), "user_id", userID); err == nil {
			if user.Type&model.UserTypeRole != 0 {
				return dao.GetMenuWithUser(dao.GetDB(), "", 0, userID)
			} else {
				return dao.GetMenu(dao.GetDB(), "", 0, "")
			}
		}
	}
	return dao.GetMenu(dao.GetDB(), "", 0, userID)
}

func AddMenu(ctx *jxcontext.Context, menu *model.Menu) (err error) {
	var (
		db = dao.GetDB()
	)
	if menu == nil {
		return fmt.Errorf("添加失败！menu nil")
	}
	if menu.Name == "" || menu.Level == 0 {
		return fmt.Errorf("添加失败！menu 名称和等级必须有值！")
	}
	menus, err := dao.GetMenu(db, menu.Name, menu.Level, "")
	if len(menus) > 0 {
		return fmt.Errorf("添加失败！已存在相同名称的 menu name : %v", menu.Name)
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	dao.WrapAddIDCULDEntity(menu, ctx.GetUserName())
	err = dao.CreateEntity(db, menu)
	dao.Commit(db)
	return err
}

func UpdateMenu(ctx *jxcontext.Context, menuID int, payload map[string]interface{}, isDelete bool) (num int64, err error) {
	var (
		db = dao.GetDB()
	)
	menu := &model.Menu{}
	menu.ID = menuID
	err = dao.GetEntity(db, menu)
	if err != nil {
		return 0, err
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	if !isDelete {
		valid := dao.StrictMakeMapByStructObject(payload, menu, ctx.GetUserName())
		if len(valid) > 0 {
			if num, err = dao.UpdateEntityLogically(db, menu, valid, ctx.GetUserName(), nil); err != nil {
				dao.Rollback(db)
				return 0, err
			}
		}
	} else {
		menu.DeletedAt = time.Now()
		num, err = dao.UpdateEntity(db, menu, "DeletedAt")
	}
	dao.Commit(db)
	return num, err
}

func GetRole(ctx *jxcontext.Context, name string) (roles []*model.Role, err error) {
	var (
		db = dao.GetDB()
	)
	roles, err = dao.GetRole(db, name, "")
	for _, v := range roles {
		if v.CityCodes != "" {
			if cityInfos, err := dao.GetPlaces(db, jxutils.StrListToIntList(strings.Split(v.CityCodes, ","))); err == nil {
				v.CityInfo = cityInfos
			}
		}
		if v.StoreIDs != "" {
			if stores, err := dao.GetStoreList(db, jxutils.StrListToIntList(strings.Split(v.StoreIDs, ",")), nil, nil, nil, nil, ""); err == nil {
				v.Stores = stores
			}
		}
	}
	return roles, err
}

func AddRole(ctx *jxcontext.Context, name string) (err error) {
	var (
		db = dao.GetDB()
	)
	roles, err := dao.GetRole(db, "", name)
	if len(roles) > 0 {
		return fmt.Errorf("添加失败！已存在相同名称的 role name : %v", name)
	}
	role := &model.Role{
		Name: name,
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	dao.WrapAddIDCULDEntity(role, ctx.GetUserName())
	err = dao.CreateEntity(db, role)
	dao.Commit(db)
	return err
}

func UpdateRole(ctx *jxcontext.Context, roleID int, name string, isDelete bool, brandID int, cityCodes, storeIDs []int) (num int64, err error) {
	var (
		db           = dao.GetDB()
		cityCodesStr []string
		storeIDsStr  []string
	)
	for _, v := range cityCodes {
		cityCodesStr = append(cityCodesStr, utils.Int2Str(v))
	}
	for _, v := range storeIDs {
		storeIDsStr = append(storeIDsStr, utils.Int2Str(v))
	}
	if roleID == 1 {
		return 0, fmt.Errorf("管理员不允许修改！")
	}
	role := &model.Role{}
	role.ID = roleID
	err = dao.GetEntity(db, role)
	if err != nil {
		return 0, err
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	if !isDelete {
		role.Name = name
		role.UpdatedAt = time.Now()
		role.LastOperator = ctx.GetUserName()
		role.BrandID = brandID
		role.CityCodes = strings.Join(cityCodesStr, ",")
		role.StoreIDs = strings.Join(storeIDsStr, ",")
		num, err = dao.UpdateEntity(db, role, "Name", "UpdatedAt", "LastOperator", "BrandID", "CityCodes", "StoreIDs")
	} else {
		role.DeletedAt = time.Now()
		num, err = dao.UpdateEntity(db, role, "DeletedAt")
	}
	dao.Commit(db)
	return num, err
}

func GetUserRole(ctx *jxcontext.Context, userID string) (userRoles []*model.UserRole, err error) {
	return dao.GetUserRole(dao.GetDB(), []string{userID}, nil)
}

func UpdateUserRole(ctx *jxcontext.Context, userIDs []string, roleIDs []int) (err error) {
	var (
		db                = dao.GetDB()
		roleIDMap         = make(map[int]int)
		nowRoleIDMap      = make(map[int]int)
		userRoleMap       = make(map[string][]int)
		addUserRoleMap    = make(map[string][]int)
		deleteUserRoleMap = make(map[string][]int)
	)
	for _, v := range roleIDs {
		roleIDMap[v] = 1
	}
	userRoles, err := dao.GetUserRole(db, userIDs, nil)
	if err != nil {
		return err
	}
	if len(userRoles) > 0 {
		for _, v := range userRoles {
			userRoleMap[v.UserID] = append(userRoleMap[v.UserID], v.RoleID)
		}
	}
	for _, userID := range userIDs {
		nowRoleIDs := userRoleMap[userID]
		for _, nowRoleID := range nowRoleIDs {
			if roleIDMap[nowRoleID] == 0 {
				deleteUserRoleMap[userID] = append(deleteUserRoleMap[userID], nowRoleID)
			}
			nowRoleIDMap[nowRoleID] = 1
		}
		for roleID, _ := range roleIDMap {
			if nowRoleIDMap[roleID] == 0 {
				addUserRoleMap[userID] = append(addUserRoleMap[userID], roleID)
			}
		}
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	if len(addUserRoleMap) > 0 {
		for userID, roleIDs := range addUserRoleMap {
			for _, roleID := range roleIDs {
				userRole := &model.UserRole{
					UserID: userID,
					RoleID: roleID,
				}
				dao.WrapAddIDCULDEntity(userRole, ctx.GetUserName())
				err = dao.CreateEntity(db, userRole)
			}
		}
	}
	if len(deleteUserRoleMap) > 0 {
		for userID, roleIDs := range deleteUserRoleMap {
			for _, roleID := range roleIDs {
				userRoles, _ := dao.GetUserRole(db, []string{userID}, []int{roleID})
				if len(userRoles) > 0 {
					userRoles[0].DeletedAt = time.Now()
					userRoles[0].LastOperator = ctx.GetUserName()
					_, err = dao.UpdateEntity(db, userRoles[0], "DeletedAt", "LastOperator")
				}
			}
		}
	}
	for _, v := range userIDs {
		if user, err := dao.GetUserByID(db, "user_id", v); err == nil {
			user.Type = user.Type | model.UserTypeRole
			dao.UpdateEntity(db, user, "Type")
		}
	}
	dao.Commit(db)
	return err
}

func GetRoleMenu(ctx *jxcontext.Context, roleID int) (roleMenus []*model.RoleMenu, err error) {
	return dao.GetRoleMenu(dao.GetDB(), []int{roleID}, nil)
}

func UpdateRoleMenu(ctx *jxcontext.Context, roleIDs, menuIDs []int) (err error) {
	var (
		db                = dao.GetDB()
		menuIDMap         = make(map[int]int)
		nowMenuIDMap      = make(map[int]int)
		roleMenuMap       = make(map[int][]int)
		addRoleMenuMap    = make(map[int][]int)
		deleteRoleMenuMap = make(map[int][]int)
	)
	for _, v := range menuIDs {
		menuIDMap[v] = 1
	}
	roleMenus, err := dao.GetRoleMenu(db, roleIDs, nil)
	if err != nil {
		return err
	}
	if len(roleMenus) > 0 {
		for _, v := range roleMenus {
			roleMenuMap[v.RoleID] = append(roleMenuMap[v.RoleID], v.MenuID)
		}
	}
	for _, roleID := range roleIDs {
		nowMenuIDs := roleMenuMap[roleID]
		for _, nowMenuID := range nowMenuIDs {
			if menuIDMap[nowMenuID] == 0 {
				deleteRoleMenuMap[roleID] = append(deleteRoleMenuMap[roleID], nowMenuID)
			}
			nowMenuIDMap[nowMenuID] = 1
		}
		for menuID, _ := range menuIDMap {
			if nowMenuIDMap[menuID] == 0 {
				addRoleMenuMap[roleID] = append(addRoleMenuMap[roleID], menuID)
			}
		}
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	if len(addRoleMenuMap) > 0 {
		for roleID, menuIDs := range addRoleMenuMap {
			for _, menuID := range menuIDs {
				roleMenu := &model.RoleMenu{
					RoleID: roleID,
					MenuID: menuID,
				}
				dao.WrapAddIDCULDEntity(roleMenu, ctx.GetUserName())
				err = dao.CreateEntity(db, roleMenu)
			}
		}
	}
	if len(deleteRoleMenuMap) > 0 {
		for roleID, menuIDs := range deleteRoleMenuMap {
			for _, menuID := range menuIDs {
				roleMenus, _ := dao.GetRoleMenu(db, []int{roleID}, []int{menuID})
				if len(roleMenus) > 0 {
					roleMenus[0].DeletedAt = time.Now()
					roleMenus[0].LastOperator = ctx.GetUserName()
					_, err = dao.UpdateEntity(db, roleMenus[0], "DeletedAt", "LastOperator")
				}
			}
		}
	}
	dao.Commit(db)
	return err
}

func GetUserStoresResultMap(userID string) (resultMap map[int]int, err error) {
	var (
		db                            = dao.GetDB()
		brandIDMap                    = make(map[int]int)
		cityCodeMap                   = make(map[int]int)
		storeIDMap                    = make(map[int]int)
		brandIDs, cityCodes, storeIDs []int
		stores                        []*model.Store
	)
	resultMap = make(map[int]int)
	userRoles, err := dao.GetUserRole2(db, []string{userID}, nil)
	for _, v := range userRoles {
		if _, ok := brandIDMap[v.BrandID]; !ok {
			brandIDMap[v.BrandID] = 1
		}
		if v.CityCodes != "" {
			for _, cityCode := range jxutils.StrListToIntList(strings.Split(v.CityCodes, ",")) {
				if _, ok := cityCodeMap[cityCode]; !ok {
					cityCodeMap[cityCode] = 1
				}
			}
		}
		if v.StoreIDs != "" {
			for _, storeID := range jxutils.StrListToIntList(strings.Split(v.StoreIDs, ",")) {
				if _, ok := storeIDMap[storeID]; !ok {
					storeIDMap[storeID] = 1
				}
			}
		}
	}
	for k, _ := range brandIDMap {
		brandIDs = append(brandIDs, k)
	}
	for k, _ := range cityCodeMap {
		cityCodes = append(cityCodes, k)
	}
	for k, _ := range storeIDMap {
		storeIDs = append(storeIDs, k)
	}
	if brandIDMap[0] != 0 {
		if cityCodeMap[0] != 0 {
			stores, err = dao.GetStoreList(db, nil, nil, nil, nil, nil, "")
		} else {
			stores, err = dao.GetStoreList(db, storeIDs, cityCodes, nil, nil, nil, "")
		}
	} else {
		if cityCodeMap[0] != 0 {
			stores, err = dao.GetStoreList(db, nil, nil, nil, brandIDs, nil, "")
		} else {
			stores, err = dao.GetStoreList(db, storeIDs, cityCodes, nil, brandIDs, nil, "")
		}
	}

	for _, v := range stores {
		if _, ok := resultMap[v.ID]; !ok {
			resultMap[v.ID] = v.ID
		}
	}
	return resultMap, err
}

func IsRoled(ctx *jxcontext.Context) bool {
	if ctx.GetUserName() != "jxadmin" {
		if user, err := dao.GetUserByID(dao.GetDB(), "user_id", ctx.GetUserID()); err == nil {
			if user.Type&model.UserTypeRole != 0 {
				return true
			}
		}
	}
	return false
}