package gn

import (
	"bytes"
	"encoding/json"
	"errors"
	"eta_gn/eta_bridge/global"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
)

type AccessTokenResp struct {
	ErrResp          `description:"报错响应"`
	AccessToken      string `json:"access_token"`
	ExpiresIn        int    `json:"expires_in"`
	RefreshExpiresIn int    `json:"refresh_expires_in"`
	RefreshToken     string `json:"refresh_token"`
	TokenType        string `json:"token_type"`
	NotBeforePolicy  int    `json:"not-before-policy"`
	SessionState     string `json:"session_state"`
}

type UserBaseInfoResp struct {
	ErrResp           `description:"报错响应"`
	Sub               string `json:"sub"`
	Name              string `json:"name"`
	PreferredUsername string `json:"preferred_username"`
	GivenName         string `json:"given_name"`
	FamilyName        string `json:"family_name"`
}

type ErrResp struct {
	Error            string `json:"error" description:"错误代码"`
	ErrorDescription string `json:"error_description" description:"错误描述"`
}

func GetToken(code string) (resp *AccessTokenResp, err error) {
	code = strings.TrimSpace(code)
	if code == "" {
		err = fmt.Errorf("code不可为空")
		return
	}

	baseUrl := global.CONFIG.Gn.AuthTokenApiUrl
	params := url.Values{}
	params.Add("client_id", global.CONFIG.Gn.AuthClientId)
	params.Add("client_secret", global.CONFIG.Gn.AuthClientSecret)
	params.Add("redirect_uri", global.CONFIG.Gn.AuthSSOCallbackUrl)
	params.Add("code", code)
	params.Add("grant_type", "authorization_code")


	result, e := HttpPostAuth(baseUrl, params, "")
	if e != nil {
		err = fmt.Errorf("统一认证请求失败, %v", e)
		return
	}
	fmt.Printf("Token RequestResult: %s\n", string(result))

	if e := json.Unmarshal(result, &resp); e != nil {
		err = fmt.Errorf("解析响应失败, %v", e)
		return
	}

	if resp.Error != "" {
		err = fmt.Errorf("Token请求失败, Err: %s, ErrMsg: %s ", resp.Error, resp.ErrorDescription)
		return
	}
	return
}

func GetUserInfo(code, token string) (resp *UserBaseInfoResp, err error) {
	code = strings.TrimSpace(code)
	token = strings.TrimSpace(token)
	if code == "" || token == "" {
		err = fmt.Errorf("Code和Token不可为空, Code: %s, Token: %s", code, token)
		return
	}

	baseUrl := global.CONFIG.Gn.AuthUserApiUrl
	params := url.Values{}
	params.Add("code", code)
	params.Add("access_token", token)


	result, err := HttpPostAuth(baseUrl, params, "")

	if err != nil {
		return
	}
	fmt.Printf("UserInfoResult: %s\n", string(result))

	err = json.Unmarshal(result, &resp)
	if err != nil {
		return
	}
	if resp.Error != "" {
		err = fmt.Errorf("UserInfo请求失败, Err: %s, ErrMsg: %s ", resp.Error, resp.ErrorDescription)
		return
	}
	return
}

func HttpPostAuth(postUrl string, params url.Values, contentTypes ...string) ([]byte, error) {

	client := &http.Client{}
	req, err := http.NewRequest("POST", postUrl, bytes.NewBufferString(params.Encode()))
	if err != nil {
		return nil, err
	}
	contentType := "application/x-www-form-urlencoded;charset=utf-8"
	if len(contentTypes) > 0 && contentTypes[0] != "" {
		contentType = contentTypes[0]
	}
	req.Header.Set("content-Type", contentType)
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = resp.Body.Close()
	}()
	result, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	postData := fmt.Sprintf("%v", params)
	global.FILE_LOG.Debug("统一认证:地址：" + postUrl + ";\n请求参数：" + postData + ";\n返回参数:" + string(result))

	if !json.Valid(result) {
		err = errors.New("返回参数不是json格式")
	}
	return result, err
}

func GetUserInfoBySci(token string) (resp *UserBaseInfoResp, err error) {
	token = strings.TrimSpace(token)
	if token == "" {
		err = fmt.Errorf("Token不可为空,Token: %s", token)
		return
	}

	urlPath := fmt.Sprintf(`%s?token=%s`, `getuserinfo`, token)
	result, err := HttpGetAuth(urlPath)
	if err != nil {
		return
	}
	err = json.Unmarshal(result, &resp)
	if err != nil {
		return
	}
	if resp.Error != "" {
		err = fmt.Errorf("UserInfo请求失败, Err: %s, ErrMsg: %s ", resp.Error, resp.ErrorDescription)
		return
	}
	return
}

func HttpGetAuth(urlPath string) ([]byte, error) {
	if global.CONFIG.Gn.AuthUserApiUrl == `` {
		return nil, errors.New("授权平台同步接口地址为空")
	}
	getUrl := global.CONFIG.Gn.AuthUserApiUrl + urlPath
	client := &http.Client{}
	req, err := http.NewRequest("GET", getUrl, nil)
	if err != nil {
		return nil, err
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	result, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	global.FILE_LOG.Debug("授权平台:地址：" + getUrl + ";\n返回参数:" + string(result))

	if !json.Valid(result) {
		err = errors.New("返回参数不是json格式")
	}

	return result, err
}