package algos

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"strconv"
)

// Gorgon Gorgon加密器
type Gorgon struct {
	unix     int64
	params   string
	xSSStub  string
	cookies  string
}

// NewGorgon 创建新的Gorgon实例
func NewGorgon(params string, unix int64, xSSStub string, cookies string) *Gorgon {
	if xSSStub == "" {
		xSSStub = "00000000000000000000000000000000"
	}
	return &Gorgon{
		unix:    unix,
		params:  params,
		xSSStub: xSSStub,
		cookies: cookies,
	}
}

// hash MD5哈希
func (g *Gorgon) hash(data string) string {
	hasher := md5.New()
	hasher.Write([]byte(data))
	return hex.EncodeToString(hasher.Sum(nil))
}

// getBaseString 获取基础字符串
func (g *Gorgon) getBaseString() string {
	baseStr := g.hash(g.params)
	baseStr = baseStr + g.xSSStub

	if g.cookies != "" {
		baseStr = baseStr + g.hash(g.cookies)
	} else {
		baseStr = baseStr + "00000000000000000000000000000000"
	}

	return baseStr
}

// rbitAlgorithm 位反转算法
func (g *Gorgon) rbitAlgorithm(num int) int {
	result := ""
	tmpString := fmt.Sprintf("%08b", num)

	for i := 0; i < 8; i++ {
		result = result + string(tmpString[7-i])
	}

	val, _ := strconv.ParseInt(result, 2, 64)
	return int(val)
}

// hexString 转十六进制字符串
func (g *Gorgon) hexString(num int) string {
	tmpString := fmt.Sprintf("%x", num)
	if len(tmpString) < 2 {
		tmpString = "0" + tmpString
	}
	return tmpString
}

// reverse 反转
func (g *Gorgon) reverse(num int) int {
	tmpString := g.hexString(num)
	val, _ := strconv.ParseInt(tmpString[1:]+tmpString[:1], 16, 64)
	return int(val)
}

// encrypt 加密
func (g *Gorgon) encrypt(data string) map[string]string {
	length := 0x14
	key := []int{
		0xDF, 0x77, 0xB9, 0x40, 0xB9, 0x9B, 0x84, 0x83,
		0xD1, 0xB9, 0xCB, 0xD1, 0xF7, 0xC2, 0xB9, 0x85,
		0xC3, 0xD0, 0xFB, 0xC3,
	}

	paramList := make([]int, 0)
	for i := 0; i < 12; i += 4 {
		temp := data[8*i : 8*(i+1)]
		for j := 0; j < 4; j++ {
			val, _ := strconv.ParseInt(temp[j*2:(j+1)*2], 16, 64)
			paramList = append(paramList, int(val))
		}
	}

	paramList = append(paramList, 0x0, 0x6, 0xB, 0x1C)

	H := int(g.unix)
	paramList = append(paramList, (H&0xFF000000)>>24)
	paramList = append(paramList, (H&0x00FF0000)>>16)
	paramList = append(paramList, (H&0x0000FF00)>>8)
	paramList = append(paramList, (H&0x000000FF)>>0)

	eorResultList := make([]int, len(paramList))
	for i, val := range paramList {
		eorResultList[i] = val ^ key[i]
	}

	for i := 0; i < length; i++ {
		C := g.reverse(eorResultList[i])
		D := eorResultList[(i+1)%length]
		E := C ^ D
		F := g.rbitAlgorithm(E)
		H := ((F ^ 0xFFFFFFFF) ^ length) & 0xFF
		eorResultList[i] = H
	}

	result := ""
	for _, param := range eorResultList {
		result += g.hexString(param)
	}

	return map[string]string{
		"x-ss-req-ticket": strconv.FormatInt(g.unix*1000, 10),
		"x-khronos":       strconv.FormatInt(g.unix, 10),
		"x-gorgon":        fmt.Sprintf("0404b0d30000%s", result),
	}
}

// GetValue 获取加密值
func (g *Gorgon) GetValue() map[string]string {
	return g.encrypt(g.getBaseString())
}