package controllers

import (
	"encoding/json"
	"fmt"
	"oppmg/common/log"
	"oppmg/protocol"
	serveauth "oppmg/services/auth"
	"oppmg/storage/redisdata"
	"strconv"
	"time"

	"github.com/GeeTeam/gt3-golang-sdk/geetest"
)

type AuthController struct {
	BaseController
}

//URLMapping 实现ControllerInterface中的URLMapping
func (c *AuthController) URLMapping() {
	c.Mapping("RefreshToken", c.RefreshToken)
}

// RefreshToken ....
// @router /refresh_token [get]
func (c *AuthController) RefreshToken() {
	var msg *protocol.ResponseMessage
	defer func() {
		c.ResposeJson(msg)
	}()
	companyid := c.GetCompanyId()
	userid := c.GetUserId()
	logintoken, err := serveauth.ChangeLoginToken(userid, companyid)
	if err != nil {
		msg = protocol.NewReturnResponse(nil, err)
		return
	}
	err = serveauth.ResetLoginTokenRedis(logintoken)
	data := protocol.ResponseLogin{
		Access: logintoken,
	}
	msg = protocol.NewReturnResponse(data, err)
	return
}

// Login 登录
// @router /login [post]
func (c *AuthController) Login() {
	var msg *protocol.ResponseMessage
	defer func() {
		c.ResposeJson(msg)
	}()

	var param protocol.RequestLogin
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
		log.Error("json 解析失败", err)
		msg = protocol.BadRequestParam("1")
		return
	}
	if len(param.Account) == 0 || len(param.Password) == 0 {
		msg = protocol.BadRequestParam("10021")
		return
	}
	logintoken, err := serveauth.LoginAuthByUCenter(param.Account, param.Password)
	if err != nil {
		msg = protocol.NewReturnResponse(nil, err)
		return
	}
	err = serveauth.ResetLoginToken(logintoken)
	if err != nil {
		log.Error("token 信息记录数据库失败")
	}
	err = serveauth.ResetLoginTokenRedis(logintoken)
	if err != nil {
		log.Error("token 信息记录redis失败")
	}
	data := protocol.ResponseLogin{
		Access: logintoken,
	}
	msg = protocol.NewReturnResponse(data, nil)
	return
}

// LoginSms 登录
// @router /login [post]
func (c *AuthController) LoginSms() {
	var msg *protocol.ResponseMessage
	defer func() {
		c.ResposeJson(msg)
	}()

	var param protocol.RequestLogin
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
		log.Error("json 解析失败", err)
		msg = protocol.BadRequestParam("1")
		return
	}
	// if len(param.Account) == 0 || len(param.Password) == 0 {
	// 	msg = protocol.BadRequestParam("10021")
	// 	return
	// }
	// logintoken, err := serveauth.LoginAuthByUCenter(param.Account, param.Password)
	// if err != nil {
	// 	msg = protocol.NewReturnResponse(nil, err)
	// 	return
	// }
	// err = serveauth.ResetLoginToken(logintoken)
	// if err != nil {
	// 	log.Error("token 信息记录数据库失败")
	// }
	// err = serveauth.ResetLoginTokenRedis(logintoken)
	// if err != nil {
	// 	log.Error("token 信息记录redis失败")
	// }
	// data := map[string]interface{}{
	// 	"access": logintoken,
	// }
	// msg = protocol.NewReturnResponse(data, nil)
	return
}

//ChangeCompany 切换公司
//@Router /change_company [post]
func (c *AuthController) ChangeCompany() {
	var msg *protocol.ResponseMessage
	defer func() {
		c.ResposeJson(msg)
	}()

	var param protocol.RequestSwapCompany
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
		log.Error("json 解析失败", err)
		msg = protocol.BadRequestParam("1")
		return
	}
	userid := c.GetUserId()
	if param.CompanyId <= 0 {
		msg = protocol.BadRequestParam("1")
		return
	}
	logintoken, err := serveauth.ChangeLoginToken(userid, param.CompanyId)
	if err != nil {
		msg = protocol.NewReturnResponse(nil, err)
		return
	}
	err = serveauth.ResetLoginToken(logintoken)
	if err != nil {
		log.Error("token 信息记录数据库失败")
	}
	err = redisdata.SetLoginToken(logintoken, userid, param.CompanyId)
	if err != nil {
		log.Error("redisdata.SetLoginToken err:%s", err)
	}
	data := protocol.ResponseLogin{
		Access: logintoken,
	}
	msg = protocol.NewReturnResponse(data, err)
	return
}

//Me
//@router /me [get]
func (c *AuthController) Me() {
	var msg *protocol.ResponseMessage
	defer func() {
		c.ResposeJson(msg)
	}()
	userid := c.GetUserId()
	companyid := c.GetCompanyId()
	userinfo, err := serveauth.UserBaseInfo(userid, companyid)
	if err != nil {
		log.Error("获取用户数据失败")
	}
	menus, err := serveauth.GetUserHasMenu(userid, companyid)
	if err != nil {
		log.Error("获取用户菜单")
	}
	companys, err := serveauth.UserHasCompanys(userid)
	if err != nil {
		log.Error("获取用户的公司")
	}
	data := map[string]interface{}{
		"user":     userinfo,
		"menus":    menus,
		"companys": companys,
	}
	msg = protocol.NewReturnResponse(data, nil)
	return
}

const (
	captchaID  = "33a2abf9c5df0d6bc3b89fb39280114b"
	privateKey = "13320fd2b10199e9a2440a4fbb4d46f7"
)

func (c *AuthController) RegisterGeetest() {
	geetest := geetest.NewGeetestLib(captchaID, privateKey, 2*time.Second)
	userip := c.Ctx.Input.IP()
	status, responseBt := geetest.PreProcess("", userip)
	c.SetSession("geetest_status", status)
	c.Ctx.Output.Body(responseBt)
	return
}

func (c *AuthController) ValidateGeetest() {
	type Parameter struct {
		GeetestChallenge string `form:"geetest_challenge"`
		GeetestValidate  string `form:"geetest_validate"`
		GeetestSeccode   string `form:"geetest_seccode"`
	}

	var (
		param      Parameter
		geetestRes bool
		status     int
	)
	err := c.ParseForm(&param)
	if err != nil {
		log.Error("解析表单数据失败；%s", err)
	}
	val := c.GetSession("geetest_status")
	status, _ = strconv.Atoi(fmt.Sprint(val))
	geetest := geetest.NewGeetestLib(captchaID, privateKey, 2*time.Second)
	if status == 1 {
		geetestRes = geetest.SuccessValidate(param.GeetestChallenge, param.GeetestValidate, param.GeetestSeccode, "", "")
	} else {
		geetestRes = geetest.FailbackValidate(param.GeetestChallenge, param.GeetestValidate, param.GeetestSeccode)
	}
	res := make(map[string]interface{})
	if geetestRes {
		res["code"] = 0
		res["msg"] = "Success"
	} else {
		res["code"] = -100
		res["msg"] = "Failed"
	}
	responseBt, _ := json.Marshal(res)
	c.Ctx.Output.Body(responseBt)
	return
}