package admin

import (
	"errors"
	"strings"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	adminParam "zhiyuan/pkg/param/admin"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
)

var Admin models.Admin

func CheckLogin(phone string, password string) (int, error) {
	where := map[string]interface{}{}
	where["state"] = 1
	if phone == "admin" {
		where["username"] = phone
	} else {
		where["phone"] = phone
	}
	where["password"] = utils.MD5(password)
	admin, err := GetOne(where, nil, nil)
	if err != nil || admin == nil {
		return 0, errors.New("用户名或密码错误")
	}
	if !CheckAuth([]string{"system:login"}, admin.ID) {
		return 0, errors.New("没有权限登录")
	}
	return admin.ID, nil
}

func Login(phone string, password string) (string, error) {
	adminID, err := CheckLogin(phone, password)
	if err != nil {
		return "", err
	}
	return UpdateToken(adminID, adminParam.Entry.PC)
}

func CheckShop(shopId int, id int) bool {
	admin, _ := GetInfoByID(id, nil, nil)
	if admin == nil {
		return false
	}
	if IsSuperAdmin(admin.ID) {
		return true
	}

	for _, v := range strings.Split(admin.ShopIds, ",") {
		s, _ := db.ToInt64(v)
		if int(s) == shopId {
			return true
		}
	}
	return false
}

func Logout(id int) error {
	admin, err := GetInfoByID(id, []string{"id"}, nil)
	if err != nil || admin == nil {
		return errors.New("invalid access_token")
	}
	ClearAuthCacheByAdmin(id)
	return ClearToken(admin.ID, adminParam.Entry.PC)
}

func GetAdmins(where map[string]interface{}, fields []string, page app.Page, retVal interface{}) ([]*models.Admin, error) {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_limit"] = db.GetOffset(uint(page.PageNum), uint(page.PageSize))
	}
	return Admin.GetMulti(where, fields, retVal)
}

func CountRaw(where string, param map[string]interface{}) (int64, error) {
	query := "zy_admin WHERE " + where
	return db.CountRaw(query, param)
}

func GetAdminsRaw(where map[string]string, param map[string]interface{}, retVal interface{}) ([]*models.Admin, error) {
	return Admin.GetMultiRaw(where, param, retVal)
}

func GetOneRaw(where map[string]string, param map[string]interface{}, retVal interface{}) (*models.Admin, error) {
	return Admin.GetOneRaw(where, param, retVal)
}

func GetAdminMapByIds(adminIds []int) map[int]string {
	adminListMap := make(map[int]string, 0)
	if len(adminIds) > 0 {
		if adminList, err := GetAdmins(map[string]interface{}{"id in": adminIds}, nil, app.Page{}, nil); err == nil {
			for _, v := range adminList {
				adminListMap[v.ID] = v.Username
			}
		}
	}
	return adminListMap
}

func Add(form form.AdminAdd) (int64, error) {
	if CheckAdminDuplicate(form.Phone) {
		return 0, errors.New("手机号码已存在")
	}
	if form.Password == "" {
		form.Password = form.Phone[len(form.Phone)-6:]
	}

	adminMap := map[string]interface{}{
		"username":     form.Username,
		"password":     utils.MD5(form.Password),
		"phone":        form.Phone,
		"dept_id":      form.DeptID,
		"site_id":      form.SiteID,
		"account_name": form.AccountName,
		"account_bank": form.AccountBank,
		"account_no":   form.AccountNo,
		"role_ids":     utils.JoinIntSlice(form.RoleIds, ","),
		"shop_ids":     utils.JoinIntSlice(form.ShopIds, ","),
		"entry_date":   form.EntryDate,
		"rest_day":     form.RestDay,
		"log_ids":      form.LogIds,
	}
	adminID, err := db.InsertOne(Admin.TableName(), adminMap)
	if err != nil {
		return 0, nil
	}
	return adminID, nil
}

func AddSalesman(form form.SalesmanAdd) (int64, error) {
	if form.RoleId != 2 && form.RoleId != 3 && form.RoleId != 6 {
		return 0, errors.New("只能添加业务员、设计师或项目监理")
	}
	if CheckAdminNameDuplicate(form.Username) {
		return 0, errors.New("员工已存在")
	}
	adminMap := map[string]interface{}{
		"username":   form.Username,
		"role_ids":   form.RoleId,
		"deleted_at": 1,
	}
	adminID, err := db.InsertOne(Admin.TableName(), adminMap)
	if err != nil {
		return 0, nil
	}
	return adminID, nil
}

func InsertOne(adminMap map[string]interface{}) (int64, error) {
	return db.InsertOne(Admin.TableName(), adminMap)
}

func Update(where, data map[string]interface{}) (int64, error) {
	return db.Update(Admin.TableName(), where, data)
}

func EditByID(form form.AdminAdd, id int) error {
	if IsSuperAdmin(id) {
		return errors.New("不能编辑超级管理员")
	}
	info, err := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid admin id")
	}
	if info.Phone != form.Phone && CheckAdminDuplicate(form.Phone) {
		return errors.New("手机号码已存在")
	}
	adminMap := map[string]interface{}{
		"phone":        form.Phone,
		"username":     form.Username,
		"dept_id":      form.DeptID,
		"site_id":      form.SiteID,
		"account_name": form.AccountName,
		"account_bank": form.AccountBank,
		"account_no":   form.AccountNo,
		"role_ids":     utils.JoinIntSlice(form.RoleIds, ","),
		"shop_ids":     utils.JoinIntSlice(form.ShopIds, ","),
		"entry_date":   form.EntryDate,
		"rest_day":     form.RestDay,
		"log_ids":      form.LogIds,
	}
	if info.Password == "" && form.Password == "" {
		form.Password = form.Phone[len(form.Phone)-6:]
	}
	if form.Password != "" {
		adminMap["password"] = utils.MD5(form.Password)
	}
	_, err = db.Update(Admin.TableName(), map[string]interface{}{"id": id}, adminMap)
	ClearAdminCache(id)
	ClearAuthCacheByAdmin(id)
	return err
}

func EditStateByID(id int, state int) error {
	adminMap := map[string]interface{}{
		"state": state,
	}
	_, err := db.Update(Admin.TableName(), map[string]interface{}{"id": id}, adminMap)
	ClearAdminCache(id)
	ClearAuthCacheByAdmin(id)
	return err
}

func Count(where map[string]interface{}) (int64, error) {
	return db.Count(Admin.TableName(), where)
}

func GetOne(where map[string]interface{}, fields []string, retVal interface{}) (*models.Admin, error) {
	return Admin.GetOne(where, fields, retVal)
}

func GetInfoByToken(token string, fields []string, retVal interface{}) (*models.Admin, error) {
	return GetOne(map[string]interface{}{"access_token": token}, fields, retVal)
}

func GetInfoByID(id int, fields []string, retVal interface{}) (*models.Admin, error) {
	return GetOne(map[string]interface{}{"id": id}, fields, retVal)
}

func Password(id int, form form.Password) error {
	if IsSuperAdmin(id) {
		return errors.New("不能修改超级管理员密码")
	}
	adminInfo, err := GetInfoByID(id, []string{"id", "password"}, nil)
	if err != nil || adminInfo == nil {
		return errors.New("登录状态有误")
	}
	if form.NewPassword != form.NewPasswordRepeat {
		return errors.New("两次输入的新密码不一致")
	}
	if adminInfo.Password != utils.MD5(form.OldPassword) {
		return errors.New("原密码有误")
	}
	db.Update(Admin.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"password": utils.MD5(form.NewPassword)})
	ClearToken(id, adminParam.Entry.PC)
	return nil
}

func DeleteByID(id int) error {
	if IsSuperAdmin(id) {
		return errors.New("不能删除超级管理员")
	}
	info, _ := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid admin id")
	}
	_, err := db.DeleteSoft(Admin.TableName(), map[string]interface{}{"id": id})
	return err
}

func CheckAdminDuplicate(phone string) bool {
	adminInfo, err := GetOne(map[string]interface{}{"phone": phone}, nil, nil)
	return adminInfo != nil && err == nil
}

func CheckAdminNameDuplicate(username string) bool {
	adminInfo, err := GetOne(map[string]interface{}{"username": username}, nil, nil)
	return adminInfo != nil && err == nil
}

func GetNameByID(id int) string {
	ret, err := GetInfoByID(id, []string{"username"}, nil)
	if err != nil {
		return ""
	}
	return ret.Username
}