package service

import (
	"errors"
	"fmt"
	"path"
	"strconv"
	"strings"
	"time"
	"vamicro/extend/util"
	"vamicro/system-service/models"
	"vamicro/system-service/vo"

	"basic.com/fileServer/WeedFSClient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/logger.git"
	uuid "github.com/satori/go.uuid"
)

type UserService struct {
}

func (sv UserService) Login(loginVo vo.UserVo) (flag bool, loginAppUser vo.LoginAppUser) {
	if loginVo.UserName == "" || loginVo.Password == "" {
		return false, loginAppUser
	}
	/*if AuthInfo.ExpirationTime < time.Now().Unix() {
		loginAppUser.RoleName = "未授权用户"
		return false,loginAppUser
	}*/
	var userE models.SysUser
	rows, err := userE.FindByName(loginVo.UserName)
	if err != nil || rows == 0 {
		return false, loginAppUser
	}
	if pwdStr, err := util.Encrypt(loginVo.Password); err == nil && pwdStr == userE.Password {
		user2LoginAppUser(&userE, &loginAppUser)
		var roleE models.SysRole
		roles := roleE.FindByUserId(userE.Id)
		loginAppUser.SysRoles = roles
		if len(roles) > 0 {
			loginAppUser.RoleName = roles[0].Name
		}
		loginAppUser.HeadPic = userE.HeadPic
		return true, loginAppUser
	}
	return false, loginAppUser
}

func user2LoginAppUser(userE *models.SysUser, loginAppUser *vo.LoginAppUser) {
	loginAppUser.Id = userE.Id
	loginAppUser.Username = userE.Username
	loginAppUser.Nickname = userE.Nickname
	loginAppUser.HeadPic = userE.HeadPic
	loginAppUser.BackgroundPic = userE.BackgroundPic
	loginAppUser.UseIconType = userE.UseIconType

	permissions := make([]string, 0)
	pM := make(map[string]models.SysMenu, 0)
	var roleE models.SysRole
	var menuE models.SysMenu
	var srm models.SysRoleMenu
	var sum models.SysUserMenu
	allMenus := menuE.FindAll()
	roles := roleE.FindByUserId(userE.Id) //用户角色
	loginAppUser.SysRoles = roles

	if roles != nil && allMenus != nil {
		menuMap := make(map[string]models.SysMenu, 0)
		for _, menuE := range allMenus {
			menuMap[menuE.Id] = menuE
		}
		var userMenus []vo.SysMenuVo
		if len(roles) > 0 && roles[0].Name == "超级管理员" {
			for _, menuModel := range menuMap {
				userMenus = append(userMenus, vo.SysMenuVo{
					SysMenu: menuModel,
				})
				pM[menuModel.Id] = menuModel
			}

		} else {
			sumList, _ := sum.FindByRoleId(userE.Id)
			if nil != sumList && len(sumList) > 0 {
				for _, srmE := range sumList {
					if _, ok := pM[srmE.MenuId]; !ok {
						menuModel := menuMap[srmE.MenuId]
						pM[menuModel.Id] = menuModel

						pidArr := strings.Split(menuModel.ParentIds, ",")
						for _, pid := range pidArr {
							if pid != "" && pid != "0" {
								if _, k := pM[pid]; !k {
									pM[pid] = menuMap[pid]
								}
							}
						}

						userMenus = append(userMenus, vo.SysMenuVo{
							SysMenu: menuModel,
						})
					}
				}
			} else {
				for _, role := range roles {
					srmList, _ := srm.FindByRoleId(role.Id)
					if srmList != nil {
						//var userMenus []vo.SysMenuVo
						for _, srmE := range srmList {
							if _, ok := pM[srmE.MenuId]; !ok {
								menuModel := menuMap[srmE.MenuId]
								pM[menuModel.Id] = menuModel

								pidArr := strings.Split(menuModel.ParentIds, ",")
								for _, pid := range pidArr {
									if pid != "" && pid != "0" {
										if _, k := pM[pid]; !k {
											pM[pid] = menuMap[pid]
										}
									}
								}

								userMenus = append(userMenus, vo.SysMenuVo{
									SysMenu: menuModel,
								})
							}
						}
					}
				}
			}
		}
		loginAppUser.SysMenus = userMenus

	}
	for _, v := range pM {
		permissions = append(permissions, v.Permission)
	}
	loginAppUser.Permissions = permissions
	logger.Debug("permissions:", permissions)
}

func (sv UserService) UpdatePwd(userId string, oldPwd string, newPwd string, opUserId string) (bool, error) {
	var userE models.SysUser
	rows, err := userE.SelectById(userId)
	if err != nil || rows == 0 {
		return false, errors.New("用户未找到!")
	}
	if oldPwd != "" {
		if encryOldPwd, _ := util.Encrypt(oldPwd); encryOldPwd == userE.Password { //旧密码匹配
			encryNewPwd, err := util.Encrypt(newPwd)
			if err == nil {
				return userE.UpdatePwd(userId, encryNewPwd), nil
			} else {
				return false, err
			}
		} else {
			return false, errors.New("原密码不正确!")
		}
	} else {
		var roleE models.SysRole
		roles := roleE.FindByUserId(userE.Id) //用户角色
		opRoles := roleE.FindByUserId(opUserId)
		if len(roles) > 0 && roles[0].Name == "超级管理员" {
			return false, errors.New("您没有权限修改超级管理员的密码!")
		}
		if len(roles) > 0 && roles[0].Name == "管理员" {
			if len(opRoles) < 0 || opRoles[0].Name != "超级管理员" {
				return false, errors.New("您没有权限修改管理员的密码!")
			}
		}
		if len(roles) > 0 && roles[0].Name == "普通用户" {
			if len(opRoles) < 0 || opRoles[0].Name != "超级管理员" && opRoles[0].Name != "管理员" {
				return false, errors.New("您没有权限修改普通用户的密码!")
			}
		}
		encryNewPwd, err := util.Encrypt(newPwd)
		if err == nil {
			return userE.UpdatePwd(userId, encryNewPwd), nil
		} else {
			return false, err
		}
	}
}

func (sv UserService) AddUser(userVo vo.UserVo) (bool, string) {
	var userE models.SysUser
	var userR models.SysRole
	rows, err := userE.FindByName(userVo.UserName)
	if err != nil {
		return false, ""
	}
	if rows > 0 {
		return false, "用户名已存在"
	} else {
		if len([]byte(userVo.Password)) < 6 {
			return false, "密码长度不能小于6位"
		}
		pwdStr, err := util.Encrypt(userVo.Password)
		if err != nil {
			return false, "添加失败"
		}
		addModel := models.SysUser{
			Username:      userVo.UserName,
			Password:      pwdStr,
			Nickname:      userVo.Nickname,
			HeadPic:       userVo.HeadPic,
			BackgroundPic: models.DefaultBgPic,
		}
		if flag, err := addModel.Insert(); flag && err == nil {
			if "" == userVo.RoleId {
				_, err := userR.FindByName("普通用户")
				if err == nil {
					userVo.RoleId = userR.Id
				}
			}
			if "" != userVo.RoleId {
				userRole := models.SysUserRole{
					UserId: addModel.Id,
					RoleId: userVo.RoleId,
				}
				userRole.Insert()
			}
			return true, "添加成功"
		} else {
			return false, "添加失败"
		}
	}
}

func (sv UserService) FindAll(curUserId string) (allAppUser []vo.LoginAppUser, err error) {
	var userE models.SysUser
	rows, err := userE.SelectById(curUserId)
	if err != nil || rows == 0 {
		return nil, err
	} else {
		list, _ := userE.FindAll()
		var myself vo.LoginAppUser
		if list != nil {
			tmpList := make([]vo.LoginAppUser, 1)
			var roleE models.SysRole
			roles := roleE.FindByUserId(userE.Id)
			if roles != nil && len(roles) == 1 {
				if roles[0].Name == "超级管理员" {
					for _, u := range list {
						if u.Id == curUserId {
							user2LoginAppUser(&u, &myself)
						} else {
							var appUE vo.LoginAppUser
							user2LoginAppUser(&u, &appUE)
							tmpList = append(tmpList, appUE)
						}
					}
				} else if roles[0].Name == "管理员" {
					for _, u := range list {
						var appUE vo.LoginAppUser
						appUERoles := roleE.FindByUserId(u.Id)
						if appUERoles != nil && len(appUERoles) == 1 {
							if u.Id == curUserId {
								user2LoginAppUser(&u, &myself)
							} else if appUERoles[0].Name == "普通用户" {
								user2LoginAppUser(&u, &appUE)
								tmpList = append(tmpList, appUE)
							}
						}
					}
				} else if roles[0].Name == "普通用户" {
					for _, u := range list {
						//var appUE vo.LoginAppUser
						appUERoles := roleE.FindByUserId(u.Id)
						if appUERoles != nil && len(appUERoles) == 1 {
							if u.Id == curUserId {
								user2LoginAppUser(&u, &myself)
							}
						}
					}
				}
			}
			tmpList[0] = myself
			return tmpList, nil

		} else {
			return []vo.LoginAppUser{}, nil
		}
	}
}

func (sv UserService) FindByUserId(userId string) (userAuth vo.UserAuthVo, err error) {
	var userE models.SysUser
	rows, _ := userE.SelectById(userId)
	if rows > 0 {
		//userAuth.Id = userE.Id
		//userAuth.Username = userE.Username
		//userAuth.Nickname = userE.Nickname
		//userAuth.HeadPic = userE.HeadPic

		userAuth.SysUser = userE

		var appUE vo.LoginAppUser
		user2LoginAppUser(&userE, &appUE)
		userAuth.Menus = appUE.SysMenus

		//var roleE models.SysRole
		//var menuE models.SysMenu
		//userAuth.Menus = menuE.FindByUserId(userE.Id)
		//if nil == userAuth.Menus {
		//	roles := roleE.FindByUserId(userE.Id)
		//	if roles!=nil && len(roles) == 1{
		//		userAuth.Menus = menuE.FindByRoleId(roles[0].Id)
		//	}
		//}

		return userAuth, nil
	}
	return userAuth, errors.New("user not found")
}

func (sv UserService) SaveAuth(userEditVo *vo.UserEditVo, opuserId string) error {
	var userE models.SysUser
	rows, e1 := userE.SelectById(userEditVo.Id)
	if e1 == nil && rows > 0 {
		//var userTmp models.SysUser
		//userEditVo.UserName = rows[]
		//existU, e2 := userTmp.FindByName(userEditVo.UserName)
		//existU := -1
		e2 := e1
		if e2 == nil {
			/*if existU > 0 && userTmp.Id != userE.Id { //企图修改为他人的用户名
				return false
			}
			reUname := false
			if existU == 0 { //修改用户名为一个未被使用的用户名
				reUname = true
			}*/

			//uNewPwd, _ := util.Encrypt(userEditVo.NewPwd)
			var roleE models.SysRole
			roles := roleE.FindByUserId(userE.Id)
			if roles != nil && len(roles) == 1 {
				userRole := roles[0]
				oproles := roleE.FindByUserId(opuserId)
				if oproles[0].Name == "管理员" && userRole.Name != "普通用户" {
					return errors.New("管理员只能修改普通用户权限")
				}
				if oproles[0].Name == "普通用户" {
					return errors.New("普通用户不能修改权限")
				}
				//userRole := roles[0]
				var err error
				tx := models.GetDB().Begin()
				defer func() {
					if err != nil && tx != nil {
						tx.Rollback()
					}
				}()
				/*if reUname && userRole.Name == "普通用户" { //只有普通用户才允许修改用户名
					err = tx.Exec("update sys_user set username=? where id=?", userEditVo.UserName, userEditVo.Id).Error
					if err !=nil {
						return false
					}
				}
				if userEditVo.NewPwd !="" {//如果密码不为空，则修改密码
					err = tx.Exec("update sys_user set password=? where id=?",uNewPwd,userEditVo.Id).Error
					if err !=nil {
						return false
					}
				}*/

				//处理当前用户权限
				err = tx.Exec("delete from sys_user_menu where user_id=?", userE.Id).Error
				if err != nil {
					return err
				}
				for _, menuId := range userEditVo.MenuIds {
					err = tx.Exec("insert into sys_user_menu (id,user_id,menu_id) values (?,?,?)", uuid.NewV4().String(), userE.Id, menuId).Error
					if err != nil {
						return err
					}
				}
				tx.Commit()
				return nil
			} else {
				return errors.New("user role is not set")
			}
		}
	}
	return errors.New("user not found")
}

//上传头像
func (sv UserService) UploadHeadPic(fileBytes []byte, filename string) (string, error) {
	fileExt := path.Ext(filename)
	fileExt = strings.ToLower(fileExt)
	if fileExt != ".jpg" && fileExt != ".jpeg" && fileExt != ".png" {
		return "", errors.New("pic format error")
	}
	var sApi bhomedbapi.SysSetApi
	flag, localConf := sApi.GetServerInfo()
	if !flag || localConf.AlarmIp == "" || localConf.AlarmPort == 0 {
		logger.Debug("localConf err")
		return "", errors.New("localConf err")
	}

	var weedfsUri = "http://" + localConf.WebPicIp + ":" + strconv.Itoa(int(localConf.WebPicPort)) + "/submit?collection=headpic"
	logger.Debug("weedfsUri:", weedfsUri)
	weedFilePath, err := WeedFSClient.UploadFile(weedfsUri, filename, fileBytes, 5*time.Second)
	if err != nil {
		logger.Debug("WeedFSClient.UploadFile err:", err, filename)
		return "", errors.New("WeedFSClient.UploadFile err")
	}
	return weedFilePath, nil
}

//更新头像、昵称
func (sv UserService) UpdateProfile(userEditVo *vo.UserEditVo) bool {
	var userE models.SysUser
	rows, e1 := userE.SelectById(userEditVo.Id)
	if e1 == nil && rows > 0 {
		var err error
		tx := models.GetDB().Begin()
		defer func() {
			if err != nil && tx != nil {
				tx.Rollback()
			}
		}()
		if userEditVo.HeadPic != "" {
			err = tx.Exec("update sys_user set headpic=? where id=?", userEditVo.HeadPic, userEditVo.Id).Error
			if err != nil {
				return false
			}
		}
		if userEditVo.BackgroundPic != "" {
			err = tx.Exec("update sys_user set backgroundpic = ? where id = ?", userEditVo.BackgroundPic, userEditVo.Id).Error
			if err != nil {
				return false
			}
		}
		if userEditVo.IconType != 0 {
			err = tx.Exec("update sys_user set useIconType = ? where id = ?", userEditVo.IconType, userEditVo.Id).Error
			if err != nil {
				return false
			}
		}
		if userEditVo.Nickname != "" {
			err = tx.Exec("update sys_user set nickname=? where id=?", userEditVo.Nickname, userEditVo.Id).Error
			if err != nil {
				return false
			}
		}
		if userEditVo.NewPwd != "" {
			uppwd, err := util.Encrypt(userEditVo.NewPwd)
			if nil == err {
				err = tx.Exec("update sys_user set password=? where id=?", uppwd, userEditVo.Id).Error
				if err != nil {
					return false
				}
			} else {
				return false
			}
		}
		tx.Commit()
		return true
	}
	return false
}

func (sv UserService) GetRoles(useId string) ([]models.SysRole, error) {
	var roleE models.SysRole
	roles := roleE.FindByUserId(useId)
	tempList, err := roleE.FindAll()
	if nil != err {
		return tempList, err
	}
	var res = make([]models.SysRole, 1)
	for _, role := range tempList {
		if roles[0].Name == "管理员" {
			if role.Name == "普通用户" {
				res[0] = role
			}
		} else if "超级管理员" == roles[0].Name && role.Name != "超级管理员" {
			if role.Name == "管理员" {
				res[0] = role
			} else {
				res = append(res, role)
			}
		}
	}
	return res, nil
}

func (sv UserService) GetProfile(uid string) (loginAppUser vo.LoginAppUser) {
	var userE models.SysUser
	rows, err := userE.SelectById(uid)
	fmt.Println("user icon type is :", userE.UseIconType)
	if err != nil || rows == 0 {
		return loginAppUser
	}
	user2LoginAppUser(&userE, &loginAppUser)
	var roleE models.SysRole
	roles := roleE.FindByUserId(userE.Id)
	loginAppUser.SysRoles = roles
	if len(roles) > 0 {
		loginAppUser.RoleName = roles[0].Name
	}
	loginAppUser.HeadPic = userE.HeadPic
	loginAppUser.BackgroundPic = userE.BackgroundPic
	// loginAppUser.UseIconType = userE.UseIconType
	fmt.Println("loginAppUser icon type is :", loginAppUser.UseIconType)
	return loginAppUser
}