package algos

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"math/rand"
)

// Algo8404 8404加密器
type Algo8404 struct {
	unix    int64
	params  string
	xSSStub string
}

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

// getXGorgon 生成X-Gorgon签名
func (a *Algo8404) getXGorgon() string {
	timeHex := fmt.Sprintf("%x", a.unix)
	timeBin, _ := hex.DecodeString(timeHex)

	m := md5.Sum([]byte(a.params))
	mBytes := m[:4]

	var aaa []byte
	if a.xSSStub != "" {
		stubBytes, _ := hex.DecodeString(a.xSSStub)
		if len(stubBytes) >= 4 {
			aaa = stubBytes[:4]
		} else {
			aaa = make([]byte, 4)
		}
	} else {
		aaa = make([]byte, 4)
	}

	// 生成随机数
	a1 := rand.Intn(256)
	a2 := rand.Intn(256)

	// 构建数据
	data := make([]byte, 0)
	data = append(data, mBytes...)
	data = append(data, aaa...)
	data = append(data, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x04}...)
	data = append(data, timeBin...)

	// 初始化表
	table := make([]int, 256)
	for i := 0; i < 256; i++ {
		table[i] = i
	}

	key := []int{0x4A, 0x00, 0x16, a2, 0x47, 0x6C, 0x00, a1}

	// 第一轮处理
	w8 := 0
	for i := 0; i < 256; i++ {
		keyI := i & 7
		w10 := key[keyI]
		w9 := w8 + table[i]
		w9 = (w9 + w10) & 0xFFFFFFFF
		w10 = w9
		w10 &= 0xFFFFFF00
		w20 := (w9 - w10) & 0xFFFFFFFF
		table[i] = table[w20]
		w8 = w20
	}

	// 第二轮处理
	dataArr := make([]int, len(data))
	for i, b := range data {
		dataArr[i] = int(b)
	}

	w26 := 0
	for i := 0; i < len(dataArr); i++ {
		w25 := i
		w8_ := w25 ^ 1
		w9_ := ((w25 & 1) << 1) & 2
		w8_ = (w9_ + w8_) & 0xFFFFFFFF
		x10 := w8_ & 0xFF

		w9b := table[x10]
		w11 := (w26 ^ w9b) & 0xFFFFFFFF
		w9c := ((w26 | w9b) << 1) & 0xFFFFFFFF
		w9c = (w9c - w11) & 0xFFFFFFFF
		w26 = w9c
		x11 := w26 & 0xFF

		w12 := table[x11]
		table[x10] = w12
		table[x11] = w12

		w10_ := w12
		w11_ := dataArr[i]
		w13_ := w10_ | w12
		w10b := w10_ & w12
		wX10 := (w13_ + w10b) & 0xFF
		ks := table[wX10]

		dataArr[i] = ks ^ w11_
	}

	// 第三轮处理
	w2 := 0xFFFFFFAA
	w3 := 0x55
	w4 := 0x33
	w8_2 := (^len(dataArr)) & 0xFFFFFFFF

	for i := 0; i < len(dataArr); i++ {
		val := dataArr[i]
		w16 := ((val >> 4) & 0x0F) | ((val & 0x0F) << 4)
		dataArr[i] = w16 & 0xFF

		if i == len(dataArr)-1 {
			dataArr[i] = dataArr[0] ^ w16
		} else {
			w7 := dataArr[i]
			w16n := dataArr[i+1]
			w20 := w7 | w16n
			wI2 := w7 & w16n
			dataArr[i] = (w20 - wI2) & 0xFF
		}

		w13_ := dataArr[i]
		t1 := w2 & (w13_ << 1)
		t2 := w3 & (w13_ >> 1)
		w13_ = t1 | t2
		t3 := w13_ << 2
		t4 := w4 & (w13_ >> 2)
		mix := (t3 & 0xFFFFFFCF) | t4
		high := (mix >> 4) & 0x0F
		low := mix & 0x0FFFFFFF
		mix = ((low << 4) | high) & 0xFFFFFFFF
		w13_ = mix ^ w8_2

		dataArr[i] = w13_ & 0xFF
	}

	// 构建输出
	output := make([]byte, 0)
	output = append(output, 0x84, 0x04)
	output = append(output, byte(a1), byte(a2))
	output = append(output, 0x00, 0x00)

	for _, val := range dataArr {
		output = append(output, byte(val))
	}

	return hex.EncodeToString(output)
}

// GetValue 获取加密值
func (a *Algo8404) GetValue() map[string]string {
	return map[string]string{
		"X-Gorgon":        a.getXGorgon(),
		"X-Khronos":       fmt.Sprintf("%d", a.unix),
		"X-SS-REQ-Ticket": fmt.Sprintf("%d", a.unix*1000),
	}
}