package domain

import (
	"fmt"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-user/pkg/constant"
	"strings"
	"time"
)

const (
	FavoriteOrg = "org"
)

const (
	// 关注
	Follow = 1
	// 取消关注
	Unfollow = 2
)

// 用户基础
type UserBase struct {
	// 用户基础数据id
	UserBaseId int64 `json:"userBaseId,omitempty"`
	// 用户信息
	UserInfo *UserInfo `json:"userInfo,omitempty"`
	// 手机号码
	Account string `json:"phone,omitempty"`
	// 密码
	Password string `json:"password,omitempty"`
	// IM信息
	Im *Im `json:"im,omitempty"`
	// 关联的用户 (冗余)
	RelatedUsers []int64 `json:"relatedUsers,omitempty"`
	// 账号状态 1：正常 2.禁用 3：注销
	Status int `json:"status,omitempty"`
	// 关注的对象
	Favorite *Favorite `json:"favorite,omitempty"`
	// 创建时间
	CreatedAt time.Time `json:"createdAt,omitempty"`
	// 更新时间
	UpdatedAt time.Time `json:"updatedAt,omitempty"`
}

type Favorite struct {
	OrgItems    []int64 `json:"orgItems"`
	Referer     string  `json:"referer"`
	LastLogInAt int64   `json:"lastLogInAt"`
}

type UserBaseRepository interface {
	Save(userBase *UserBase) (*UserBase, error)
	Remove(userBase *UserBase) (*UserBase, error)
	FindOne(queryOptions map[string]interface{}) (*UserBase, error)
	Find(queryOptions map[string]interface{}) (int64, []*UserBase, error)
}

func (userBase *UserBase) Identify() interface{} {
	if userBase.UserBaseId == 0 {
		return nil
	}
	return userBase.UserBaseId
}

func (userBase *UserBase) Update(data map[string]interface{}) error {
	if userName, ok := data["userName"]; ok {
		userBase.UserInfo.UserName = userName.(string)
	}
	if phone, ok := data["phone"]; ok {
		userBase.UserInfo.Phone = phone.(string)
	}
	if avatar, ok := data["avatar"]; ok {
		userBase.UserInfo.Avatar = avatar.(string)
	}
	if email, ok := data["email"]; ok {
		userBase.UserInfo.Email = email.(string)
	}
	if account, ok := data["account"]; ok {
		userBase.Account = account.(string)
	}
	if password, ok := data["password"]; ok {
		userBase.Password = password.(string)
	}
	if accid, ok := data["accid"]; ok {
		userBase.Im.Accid = accid.(string)
	}
	if imToken, ok := data["imToken"]; ok {
		userBase.Im.ImToken = imToken.(string)
	}
	if csAccountId, ok := data["csAccountId"]; ok {
		userBase.Im.CsAccountId = csAccountId.(string)
	}
	if relatedUser, ok := data["relatedUser"]; ok {
		userBase.RelatedUsers = relatedUser.([]int64)
	}
	if status, ok := data["status"]; ok {
		userBase.Status = status.(int)
	}
	if createdAt, ok := data["createdAt"]; ok {
		userBase.CreatedAt = createdAt.(time.Time)
	}
	if updatedAt, ok := data["updatedAt"]; ok {
		userBase.UpdatedAt = updatedAt.(time.Time)
	}
	return nil
}

/*****   1.模块基础函数  *****/

// AddRelatedUser  添加账号关联的用户
//
// userId 用户id
func (userBase *UserBase) AddRelatedUser(userId int64) bool {
	if userId <= 0 {
		return false
	}
	var res = true
	for i := range userBase.RelatedUsers {
		if userBase.RelatedUsers[i] == userId {
			return false
		}
	}
	userBase.RelatedUsers = append(userBase.RelatedUsers, userId)
	return res
}

// CheckAccountPassword  检查账号密码
//
// account 账号 (手机号)
// password 密码（sha1）
func (userBase *UserBase) CheckAccountPassword(account, password string) error {
	if userBase.Status != int(UserStatusEnable) {
		return fmt.Errorf("该用户不存在")
	}
	if !strings.EqualFold(account, userBase.Account) {
		return fmt.Errorf("该用户不存在")
	}
	if !strings.EqualFold(userBase.Password, password) {
		return fmt.Errorf("密码输入错误")
	}
	return nil
}

// ResetPassword  重置密码
//
// account 账号 (手机号)
// password 密码（sha1）
func (userBase *UserBase) ResetPassword(account, password string) error {
	if userBase.Status != int(UserStatusEnable) {
		return fmt.Errorf("该用户不存在")
	}
	if !strings.EqualFold(account, userBase.Account) {
		return fmt.Errorf("该用户不存在")
	}
	userBase.Password = password
	return nil
}

// ResetPhone  重置手机号
//
// oldPhone 旧手机号
// newPhone 新手机号
func (userBase *UserBase) ResetPhone(oldPhone, newPhone string) error {
	if userBase.Status != int(UserStatusEnable) {
		return fmt.Errorf("该用户不存在")
	}
	if !strings.EqualFold(oldPhone, userBase.Account) {
		return fmt.Errorf("该用户不存在")
	}
	userBase.Account = newPhone
	userBase.UserInfo.Phone = newPhone
	return nil
}

// DestroyAccount  注销账号
//
// p1 p1_desc
func (userBase *UserBase) DestroyAccount(accountAfter string) error {
	if userBase.Status != int(UserStatusEnable) {
		return fmt.Errorf("账号已注销")
	}
	userBase.Status = int(UserStatusDestroy)
	userBase.Account = accountAfter
	userBase.UserInfo.Phone = accountAfter
	return nil
}

// UpdateUserInfo  更新用户信息
//
// userInfo 用户信息
func (userBase *UserBase) UpdateUserInfo(userInfo *UserInfo) error {
	//userBase.UserInfo.Phone = userInfo.Phone
	userBase.UserInfo.UserName = userInfo.UserName
	userBase.UserInfo.Email = userInfo.Email
	userBase.UserInfo.Avatar = userInfo.Avatar
	userBase.UpdatedAt = time.Now()
	return nil
}

func (userBase *UserBase) AddFavorite(favoriteItem string, code int64) error {
	if userBase.Favorite == nil {
		userBase.Favorite = NewFavorite()
	}
	var err error
	switch favoriteItem {
	case FavoriteOrg:
		userBase.Favorite.OrgItems, err = userBase.addFavorite(userBase.Favorite.OrgItems, code)
	default:
		return fmt.Errorf("unkown type " + favoriteItem)
	}
	return err
}

func (userBase *UserBase) RemoveFavorite(favoriteItem string, code int64) error {
	if userBase.Favorite == nil {
		userBase.Favorite = NewFavorite()
		return nil
	}
	var err error
	switch favoriteItem {
	case FavoriteOrg:
		userBase.Favorite.OrgItems, err = userBase.removeFavorite(userBase.Favorite.OrgItems, code)
	default:
		return fmt.Errorf("unkown type " + favoriteItem)
	}
	return err
}

func NewFavorite() *Favorite {
	return &Favorite{
		OrgItems: make([]int64, 0),
	}
}

// addFavorite  收藏
//
// codes 菜单列表
func (userBase *UserBase) addFavorite(items []int64, code int64) ([]int64, error) {
	var existed = false
	for j := 0; j < len(items); j++ {
		if items[j] == code {
			existed = true
		}
	}
	if !existed {
		items = append(items, code)
	}

	return items, nil
}

// removeFavorite  收藏移除
//
// codes 菜单列表
func (userBase *UserBase) removeFavorite(items []int64, code int64) ([]int64, error) {
	var newItems = make([]int64, 0)

	for i := 0; i < len(items); i++ {
		if items[i] == code {
			continue
		}
		newItems = append(newItems, items[i])
	}
	return newItems, nil
}

// LastLogIn 更新最后一次登录时间
//
// t  时间
func (userBase *UserBase) LastLogIn(t time.Time) error {
	if userBase.Favorite == nil {
		userBase.Favorite = NewFavorite()
	}
	userBase.Favorite.LastLogInAt = t.Unix()
	return nil
}

func (user *UserBase) SetEnableStatus(status int) error {
	userStatus := UserStatus(user.Status)
	if userStatus == UserStatusDestroy {
		return fmt.Errorf("账号已注销")
	}
	if user.Status == status {
		return nil //fmt.Errorf("重复设置状态")
	}
	if !(status == int(UserStatusEnable) || status == int(UserStatusDisable)) {
		return fmt.Errorf("非法启用状态")
	}
	user.Status = status
	return nil
}

/*****   2.缓存模块  *****/

func (m *UserBase) CacheKeyFunc() string {
	if constant.DISABLE_REPOSITORY_CACHE {
		return ""
	}
	if m.UserBaseId == 0 {
		return ""
	}
	return fmt.Sprintf("%v:cache:userbase:id:%v", constant.CACHE_PREFIX, m.UserBaseId)
}