package models

import (
	"errors"
	"spaceofcheng/services/models/model"
	"strings"
	"time"

	"github.com/yl10/kit/guid"
)

// GetPureUserInfo 获取用户基本信息
func GetPureUserInfo(id string) (*model.SysUser, error) {
	user := model.SysUser{}

	has, err := DBEngine.Where("user_id=?", id).Get(&user)
	if err != nil {
		return nil, err
	}

	if !has {
		return nil, errors.New("没有查询到 ID (" + id + ") 对应的用户")
	}

	if user.Status != STATUS_NORMAL {
		return nil, errors.New("用户状态不正确")
	}

	return &user, nil
}

// GetUserMenu 获取用户菜单
func GetUserMenu(userID string) ([]model.SysMenu, error) {
	query := `
		SELECT t.*
		FROM sys_menu t
			JOIN sys_user_menu s ON t.menu_id = s.menu_id
		WHERE s.user_id = ?
			AND t.status = ?
		ORDER BY t.order_no ASC
	`

	var menus []model.SysMenu
	if err := DBEngine.SQL(query, userID, STATUS_NORMAL).Find(&menus); err != nil {
		return nil, err
	}

	return menus, nil
}

// GetUserCase 获取用户案场
func GetUserCase(userID string) ([]model.SysUserCase, error) {
	query := `
		SELECT t.*
		FROM sys_user_case t
		inner join sys_case b on t.case_id=b.case_id
		WHERE t.user_id = ?
			AND t.status = ? and b.case_id>?
	`

	var cases []model.SysUserCase
	if err := DBEngine.SQL(query, userID, STATUS_NORMAL, STATUS_DEL).Find(&cases); err != nil {
		return nil, err
	}

	return cases, nil
}

// GetOrg 获取机构信息
func GetOrg(orgID string) (*model.SysOrg, error) {
	var org model.SysOrg
	has, err := DBEngine.Where("org_id=?", orgID).And("status=?", STATUS_NORMAL).Get(&org)
	if err != nil {
		return nil, err
	}

	if !has {
		return nil, errors.New("没有查询到机构信息")
	}

	return &org, nil
}

// GetCustomer 获取用户信息
// 暂时无法解决 一个用户 多组织架构的问题
func GetCustomer(custID string) (*model.TaCustomer, error) {
	var cust model.TaCustomer

	has, err := DBEngine.Where("customer_id=?", custID).And("status=?", STATUS_NORMAL).Get(&cust)
	if err != nil {
		return nil, err
	}

	if !has {
		return nil, errors.New("没有查询到客户 (id: " + custID + ") 信息")
	}

	return &cust, nil
}

// GetUserMappingByOpenID 获取用户映射信息
func GetUserMappingByOpenID(openID string) ([]model.TaUserMapping, error) {
	var users []model.TaUserMapping

	err := DBEngine.Where("openid=?", openID).Find(&users)
	return users, err
}

// EditUserMapping 保存用户映射信息
func EditUserMapping(user *model.TaUserMapping) error {
	// 如果没有映射ID, 则新增记录
	if user.MappingId == "" {
		user.MappingId = guid.NewGUIDString()
		_, err := DBEngine.Insert(user)
		return err
	}

	// 否则更新记录
	cols := []string{
		"account_info",
	}
	_, err := DBEngine.Cols(cols...).
		Where("account_type=?", user.AccountType).
		And("openid=?", user.Openid).
		Update(user)
	return err
}

// GetWeChatConfig 获取微信配置
func GetWeChatConfig(org, cliType string) (map[string]string, error) {
	conf := new(model.SysWechatConf)

	if _, err := DBEngine.Where("org_id=?", org).And("type=?", cliType).Get(conf); err != nil {
		return nil, err
	}

	if conf.ConfId == "" {
		return nil, nil
	}

	cert := map[string]string{
		"appid":  conf.Appid,
		"secret": conf.Secret,
		"token":  conf.Token,
		"aeskey": conf.Aeskey,
		"wxid":   conf.Wxid,
	}

	return cert, nil
}

// InsertToken 插入 token 生成记录
func InsertToken(token, uid, batchNo string, expire time.Time) error {
	tk := model.SysTokenLog{
		Token:      token,
		Uid:        uid,
		BatchNo:    batchNo,
		ExpireDate: expire,
		Status:     STATUS_NORMAL,
		CreateDate: time.Now().Local(),
	}

	if _, err := DBEngine.Insert(&tk); err != nil {
		return err
	}

	return nil
}

// UpdateTokenExpire 设置 token 过期
func UpdateTokenExpire(token, uid string) error {
	tk := model.SysTokenLog{
		Status: STATUS_DEL,
	}

	// 检索相同批次
	var tkLogs []model.SysTokenLog
	if err := DBEngine.Where("token=?", token).Find(&tkLogs); err != nil {
		return err
	}

	// 如果有相同批次的, 则更新本批次为失效
	if tkLogs != nil && len(tkLogs) > 0 {
		batchNo := []string{}

		for _, t := range tkLogs {
			if t.BatchNo != "" {
				batchNo = append(batchNo, t.BatchNo)
			}
		}

		if len(batchNo) > 0 {

			if _, err := DBEngine.Cols("status").
				Where("token=?", token).
				Or("batch_no in ('" + strings.Join(batchNo, "','") + "')").
				Update(&tk); err != nil {
				return err
			}

			return nil
		}
	}

	if _, err := DBEngine.Cols("status").Where("token=?", token).Or("uid=?", uid).Update(&tk); err != nil {
		return err
	}

	return nil
}

// GetToken 获取 token
func GetToken(token string) (*model.SysTokenLog, error) {
	tk := model.SysTokenLog{}

	if _, err := DBEngine.Where("token=?", token).Get(&tk); err != nil {
		return nil, err
	}

	return &tk, nil
}

// GetCustomerByID 依据ID获取客户
func GetCustomerByID(id string) (*model.TaCustomer, error) {
	cust := new(model.TaCustomer)

	if _, err := DBEngine.Where("customer_id=?", id).Get(cust); err != nil {
		return nil, err
	}

	return cust, nil
}

func SaveCustomer(cust *model.TaCustomer) error {
	cust.CustomerId = guid.NewGUIDString()
	cust.CreateDate = time.Now().Local()
	cust.Status = STATUS_NORMAL

	_, err := DBEngine.Insert(cust)
	return err
}

// SaveAccount 保存账户信息
func SaveAccount(account *model.TaCustomerAccount) error {
	if account.CustomerId == "" {
		return errors.New("账户未关联人员")
	}

	account.Status = STATUS_NORMAL
	account.CreateDate = time.Now().Local()
	account.AccountId = guid.NewGUIDString()

	_, err := DBEngine.Insert(account)
	return err
}

// UpdateUserMapping 更新用户映射
func UpdateUserMapping(userMap *model.TaUserMapping, cols []string) error {
	if userMap.MappingId == "" {
		return errors.New("用户映射信息不存在")
	}

	_, err := DBEngine.Where("mapping_id=?", userMap.MappingId).Cols(cols...).Update(userMap)
	return err
}

// GetAllCases 获取所有有效案场
func GetAllCases() ([]model.SysCase, error) {
	var cases []model.SysCase
	err := DBEngine.Where("status=?", STATUS_NORMAL).Asc("org_id").Find(&cases)
	return cases, err
}

// GetCaseByID 获取案场
func GetCaseByID(caseID string) (cs *model.SysCase, err error) {
	cs = new(model.SysCase)

	_, err = DBEngine.Where("case_id=?", caseID).Get(cs)
	return cs, err
}

// GetAllOrgs 获取所有机构
func GetAllOrgs() ([]model.SysOrg, error) {
	var orgs []model.SysOrg
	err := DBEngine.Where("status=?", STATUS_NORMAL).Asc("org_id").Find(&orgs)

	return orgs, err
}

func GetSeqID(key string) (string, error) {
	query := "select nextval('" + key + "') as seqid"

	res, err := DBEngine.QueryString(query)
	if err != nil {
		return "", err
	}

	return res[0]["seqid"], nil
}