package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"gas-cylinder-api/app/admin/model"
	"gas-cylinder-api/app/admin/service/dto"
	"gas-cylinder-api/common/global"
	"gas-cylinder-api/common/middleware/handler"
	model2 "gas-cylinder-api/common/model"
	"gas-cylinder-api/conf"
	"github.com/dgrijalva/jwt-go"
	"github.com/gin-gonic/gin"
	"gogs.baozhida.cn/zoie/OAuth-core/pkg"
	"gogs.baozhida.cn/zoie/OAuth-core/pkg/utils"
	"gogs.baozhida.cn/zoie/OAuth-core/sdk"
	"gogs.baozhida.cn/zoie/OAuth-core/service"
	"gorm.io/gorm"
	"net/http"
	"time"
)

type AppletCustomer struct {
	service.Service
}

func GetAppletCustomerId(c *gin.Context) string {
	customerId, exists := c.Get("customer_id")
	if !exists {
		return ""
	}
	return customerId.(string)
}

// GetPage 获取Customer列表
func (e *AppletCustomer) WxLogin(c *dto.AppletCustomerWxLoginReq) (token, expiresAt string, err error) {
	var data model.Customer

	url := "https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code"
	appid := conf.ExtConfig.Applet.Appid
	appSecret := conf.ExtConfig.Applet.AppSecret
	url = fmt.Sprintf(url, appid, appSecret, c.Code)
	// 发起请求
	res, _ := http.Get(url)

	// 成功后获取openId
	wxRes := dto.AppletCustomerLoginResp{}
	err = json.NewDecoder(res.Body).Decode(&wxRes)

	if err != nil || wxRes.Openid == "" {
		return token, expiresAt, errors.New("获取openid失败")
	}

	err = e.Orm.Where("principal_phone = ?", c.Phone).First(&data).Error
	id := data.Id
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 添加客户
			for {
				var count int64
				id = utils.GetUUID()
				var i int64
				err = e.Orm.Model(&data).Where("id = ?", id).Count(&count).Error
				if err != nil {
					continue
				}
				if i == 0 {
					break
				}
			}
			err = e.Orm.Create(&model.Customer{
				ProvCustomer: model.ProvCustomer{
					Id:             id,
					PrincipalPhone: c.Phone,
				},
				Openid: wxRes.Openid,
			}).Error
		} else {
			return token, expiresAt, errors.New("获取个人信息失败")
		}
	}

	if data.Openid != wxRes.Openid {
		data.Openid = wxRes.Openid
		err = e.Orm.Save(&data).Error
		if err != nil {
			return token, expiresAt, errors.New("同步个人信息失败")
		}
	}

	token, expiresAt, _ = e.GeneratorToken(id)
	return token, expiresAt, nil

}
func (e *AppletCustomer) Login(c *dto.AppletCustomerLoginReq) (token, expiresAt string, err error) {
	var data model.Customer

	err = e.Orm.Where("principal_phone = ? and dept_id = -1", c.Phone).First(&data).Error
	id := data.Id
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return token, expiresAt, errors.New("用户名或密码错误")
		} else {
			return token, expiresAt, err
		}
	}

	if len(c.VerifyCode) > 0 {
		code, err := sdk.Runtime.GetCacheAdapter().Get(handler.GetVerifyCodeCacheKey(c.Phone))
		if err != nil {
			e.Log.Errorf("user login error, %s", err.Error())
			err = errors.New("验证码已过期")
			return token, expiresAt, err
		}
		if code != c.VerifyCode {
			e.Log.Errorf("user login error, %s", "验证码错误")
			err = errors.New("验证码错误")
			return token, expiresAt, err
		}
		token, expiresAt, _ = e.GeneratorToken(id)
		return token, expiresAt, nil
	}

	_, err = pkg.CompareHashAndPassword(data.Password, c.Password)
	if err != nil {
		e.Log.Errorf("user login error, %s", err.Error())
		return token, expiresAt, errors.New("用户名或密码错误")
	}

	token, expiresAt, _ = e.GeneratorToken(id)
	return token, expiresAt, nil

}

//	func (e *AppletCustomer) Refresh(oldToken string) (token, expiresAt string, err error) {
//		var data model.Customer
//
//		err = e.Orm.Where("principal_phone = ? and dept_id = -1", c.Phone).First(&data).Error
//		id := data.Id
//		if err != nil {
//			if errors.Is(err, gorm.ErrRecordNotFound) {
//				return token, expiresAt, errors.New("用户名或密码错误")
//			} else {
//				return token, expiresAt, err
//			}
//		}
//
//		if len(c.VerifyCode) > 0 {
//			code, err := sdk.Runtime.GetCacheAdapter().Get(handler.GetVerifyCodeCacheKey(c.Phone))
//			if err != nil {
//				e.Log.Errorf("user login error, %s", err.Error())
//				err = errors.New("验证码已过期")
//				return token, expiresAt, err
//			}
//			if code != c.VerifyCode {
//				e.Log.Errorf("user login error, %s", "验证码错误")
//				err = errors.New("验证码错误")
//				return token, expiresAt, err
//			}
//			token, expiresAt, _ = e.GeneratorToken(id)
//			return token, expiresAt, nil
//		}
//
//		_, err = pkg.CompareHashAndPassword(data.Password, c.Password)
//		if err != nil {
//			e.Log.Errorf("user login error, %s", err.Error())
//			return token, expiresAt, errors.New("用户名或密码错误")
//		}
//
//		token, expiresAt, _ = e.GeneratorToken(id)
//		return token, expiresAt, nil
//
// }
func (e *AppletCustomer) Register(c *dto.AppletCustomerRegisterReq) (err error) {
	var data model.Customer
	code, err := sdk.Runtime.GetCacheAdapter().Get(handler.GetVerifyCodeCacheKey(c.Phone))
	if err != nil {
		e.Log.Errorf("user login error, %s", err.Error())
		err = errors.New("验证码已过期")
		return
	}
	if code != c.VerifyCode {
		e.Log.Errorf("user login error, %s", "验证码错误")
		err = errors.New("验证码错误")
		return
	}

	err = e.Orm.Where("principal_phone = ? and dept_id = -1", c.Phone).First(&data).Error
	id := data.Id
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 添加客户
			for {
				var count int64
				id = utils.GetUUID()
				var i int64
				err = e.Orm.Model(&data).Where("id = ?", id).Count(&count).Error
				if err != nil {
					continue
				}
				if i == 0 {
					break
				}
			}
			err = e.Orm.Create(&model.Customer{
				ProvCustomer: model.ProvCustomer{
					Type:           c.Type,
					Id:             id,
					PrincipalPhone: c.Phone,
				},
				//Openid: wxRes.Openid,
				Password: c.Password,
				DeptBy: model2.DeptBy{
					DeptId: -1,
				},
			}).Error
		} else {
			return err
		}
	}

	if len(data.Id) > 0 {
		return errors.New("该手机号已注册")
	}

	return nil

}

func (e *AppletCustomer) GeneratorToken(customerId string) (string, string, error) {
	// 创建一个我们自己的声明
	var TokenExpireDuration = time.Second * 24 * 3600 * time.Duration(conf.ExtConfig.Applet.TokenExpire)
	expiresAt := time.Now().Add(TokenExpireDuration)
	c := model.CustomerClaims{
		customerId,
		jwt.StandardClaims{
			ExpiresAt: expiresAt.Unix(), // 过期时间
			Issuer:    "customer",       // 签发人
		},
	}
	// 使用指定的签名方法创建签名对象
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, c)
	// 使用指定的secret签名并获得完整的编码后的字符串token
	tokenStr, err := token.SignedString(model.AppletCustomerSecret)
	return tokenStr, expiresAt.Format("2006-01-02 15:04:05"), err
}

// UpdatePwd 修改SysUser对象密码
func (e *AppletCustomer) UpdatePwd(id string, oldPassword, newPassword string) error {
	var err error

	if newPassword == "" {
		return nil
	}
	c := &model.Customer{}

	err = e.Orm.Model(c).
		Select("id", "password").
		Where("id = ?", id).
		First(c).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return global.UpdateNotFoundOrNoPermissionErr
		}
		return errors.New("密码修改失败")
	}
	var ok bool
	ok, err = pkg.CompareHashAndPassword(c.Password, oldPassword)
	if err != nil {
		e.Log.Errorf("CompareHashAndPassword error, %s", err.Error())
		return errors.New("密码修改失败")
	}
	if !ok {
		err = errors.New("incorrect Password")
		e.Log.Warnf("user[%d] %s", id, err.Error())
		return err
	}
	c.Password = newPassword
	db := e.Orm.Model(c).Where("id = ?", id).
		Select("Password", "Salt").
		Updates(c)
	if err = db.Error; err != nil {
		if errors.Is(err, model.ErrForbidUpdateSysRole) {
			return model.ErrForbidUpdateSysRole
		}
		e.Log.Errorf("db error: %s", err)
		return errors.New("密码修改失败")
	}
	return nil
}