import random
import math
from typing import Any, Optional


# 生成类人的鼠标轨迹
def generate_realistic_trajectory(
    start_x: int, start_y: int, end_x: int, end_y: int, start_time: int
) -> list[Any]:
    """生成类人的鼠标轨迹"""
    trajectory = []

    # 计算距离和步数
    distance = ((end_x - start_x) ** 2 + (end_y - start_y) ** 2) ** 0.5
    steps = int(distance / 2) + random.randint(5, 15)  # 根据距离动态调整步数

    current_time = start_time
    current_x, current_y = start_x, start_y

    for i in range(steps):
        # 使用贝塞尔曲线模拟自然移动
        progress = i / steps

        # 添加缓动函数（开始快，中间慢，结束快）
        if progress < 0.3:
            eased = progress / 0.3 * 0.2
        elif progress < 0.7:
            eased = 0.2 + (progress - 0.3) / 0.4 * 0.5
        else:
            eased = 0.7 + (progress - 0.7) / 0.3 * 0.3

        # 计算目标位置（添加随机抖动）
        target_x = start_x + (end_x - start_x) * eased
        target_y = start_y + (end_y - start_y) * eased

        # 添加微小的随机偏移（模拟手抖）
        jitter_x = random.uniform(-0.5, 0.5)
        jitter_y = random.uniform(-0.5, 0.5)

        current_x = int(target_x + jitter_x)
        current_y = int(target_y + jitter_y)

        # 随机时间间隔（3-25ms，符合人类反应）
        time_delta = random.choices(
            [3, 4, 5, 6, 7, 8, 10, 12, 15, 20, 24],
            weights=[5, 8, 10, 12, 10, 8, 5, 3, 2, 1, 1],
        )[0]
        current_time += time_delta

        trajectory.append(["move", current_x, current_y, current_time, "pointermove"])

        # 偶尔在同一位置停留（模拟视觉确认）
        if random.random() < 0.15:
            trajectory.append(
                [
                    "move",
                    current_x,
                    current_y,
                    current_time + random.randint(5, 15),
                    "pointermove",
                ]
            )
            current_time += random.randint(5, 15)

    # 到达目标后的悬停
    hover_time = random.randint(50, 150)
    for _ in range(random.randint(2, 5)):
        current_time += random.randint(8, 25)
        trajectory.append(
            [
                "move",
                end_x + random.randint(-1, 1),
                end_y + random.randint(-1, 1),
                current_time,
                "pointermove",
            ]
        )

    current_time += hover_time

    # 点击事件
    trajectory.append(["down", end_x, end_y, current_time, "pointerdown"])

    trajectory.append(["focus", current_time + 1])

    click_duration = random.randint(80, 130)
    trajectory.append(["up", end_x, end_y, current_time + click_duration, "pointerup"])

    return trajectory


# 处理原始轨迹数组
def process_mouse_trajectory(
    events: list[Any], max_records: Optional[int] = None
) -> dict[str, Any]:
    """
    处理鼠标/触摸轨迹数据，将绝对坐标转换为相对坐标和时间差

    参数:
        events: 原始事件数据列表
        max_records: 最大保留记录数（None表示保留全部）

    返回:
        处理后的事件列表
    """
    if not events or len(events) == 0:
        return {"data": [], "first_event": None, "last_event": None, "total_events": 0}

    # 初始化变量
    prev_x = 0  # 上一个X坐标
    prev_y = 0  # 上一个Y坐标
    prev_time = 0  # 上一个时间戳
    result = []  # 结果数组
    first_event = None  # 第一个事件
    last_event = None  # 最后一个事件

    # 移动类事件（包含坐标信息）
    MOVE_EVENTS = ["move", "mousemove", "touchmove", "pointermove"]

    # 点击类事件（仅时间信息）
    CLICK_EVENTS = [
        "down",
        "up",
        "click",
        "mousedown",
        "mouseup",
        "touchstart",
        "touchend",
        "pointerdown",
        "pointerup",
    ]

    # 特殊事件（仅时间信息）
    TIME_ONLY_EVENTS = ["focus", "blur", "keydown", "keyup"]

    # 如果设置了最大记录数，只处理最后N条
    start_index = 0
    if max_records and len(events) > max_records:
        start_index = len(events) - max_records

    # 遍历事件
    for i in range(start_index, len(events)):
        event = events[i]
        event_type = event[0]

        # 处理移动类事件（包含X, Y坐标）
        if event_type in MOVE_EVENTS:
            x = event[1]
            y = event[2]
            timestamp = event[3]

            # 记录第一个和最后一个事件
            if first_event is None:
                first_event = event
            last_event = event

            # 计算相对坐标差值
            delta_x = x - prev_x
            delta_y = y - prev_y

            # 计算时间差
            if prev_time == 0:
                time_diff = 0  # 第一个事件时间差为0
            else:
                time_diff = timestamp - prev_time

            # 添加到结果数组
            result.append([event_type, [delta_x, delta_y], time_diff])

            # 更新上一次的值
            prev_x = x
            prev_y = y
            prev_time = timestamp

        # 处理点击类事件（包含坐标但只记录时间差）
        elif event_type in CLICK_EVENTS:
            timestamp = event[3] if len(event) > 3 else event[1]

            # 计算时间差
            if prev_time == 0:
                time_diff = 0
            else:
                time_diff = timestamp - prev_time

            # 添加到结果数组（坐标差为[0,0]）
            result.append([event_type, [0, 0], time_diff])

            prev_time = timestamp

        # 处理仅时间类事件（如focus）
        elif event_type in TIME_ONLY_EVENTS:
            timestamp = event[1]

            # 计算时间差
            if prev_time == 0:
                time_diff = 0
            else:
                time_diff = timestamp - prev_time

            # 添加到结果数组（仅包含时间差）
            result.append([event_type, time_diff])

            prev_time = timestamp

    return {
        "data": result,
        "first_event": first_event,
        "last_event": last_event,
        "total_events": len(result),
    }


def compress_trajectory(e: list[Any]) -> str:
    """
    压缩轨迹数据的完整实现

    Args:
        e: 轨迹数据列表

    Returns:
        压缩后的 Base64 编码字符串
    """
    # 事件类型映射
    p = {
        "move": 0,
        "down": 1,
        "up": 2,
        "scroll": 3,
        "focus": 4,
        "blur": 5,
        "unload": 6,
        "unknown": 7,
    }

    def h(e, t):
        """
        填充二进制字符串

        Args:
            e: 数值
            t: 目标长度

        Returns:
            填充后的二进制字符串
        """
        n = bin(e)[2:]  # 转为二进制并去掉 '0b' 前缀
        r = ""
        o = len(n) + 1
        while o <= t:
            r += "0"
            o += 1
        return r + n

    def f(e):
        """
        压缩事件类型数组

        Args:
            e: 事件类型列表

        Returns:
            压缩后的二进制字符串
        """
        t = []
        n = len(e)
        r = 0

        # 游程编码（Run-Length Encoding）
        while r < n:
            o = e[r]
            i = 0
            while True:
                if 16 <= i:
                    break
                s = r + i + 1
                if n <= s:
                    break
                if e[s] != o:
                    break
                i += 1

            r = r + 1 + i
            a = p[o]
            if i != 0:
                t.append(8 | a)  # 设置重复标志位
                t.append(i - 1)
            else:
                t.append(a)

        # 编码长度信息
        _ = h(32768 | n, 16)
        c = ""
        for l in range(len(t)):
            c += h(t[l], 4)

        return _ + c

    def c(e, t):
        """
        对数组每个元素应用函数

        Args:
            e: 输入数组
            t: 转换函数

        Returns:
            转换后的数组
        """
        n = []
        for r in range(len(e)):
            n.append(t(e[r]))
        return n

    def d(e, t):
        """
        压缩数值数组（游程编码 + 变长编码）

        Args:
            e: 数值数组
            t: 是否为坐标数据（需要过滤符号位）

        Returns:
            压缩后的二进制字符串
        """

        # 第一步：限制数值范围到 [-32767, 32767]
        def limit_value(val):
            limit = 32767
            return max(-limit, min(limit, val))

        e = c(e, limit_value)

        # 第二步：游程编码（Run-Length Encoding）
        n = len(e)
        r = 0
        o = []

        while r < n:
            i = 1
            s = e[r]
            a = abs(s)

            # 统计连续相同的值
            while r + i < n and e[r + i] == s and a < 127 and i < 127:
                i += 1

            if i > 1:
                # 重复值编码格式：
                # 位15: 符号标志 (1=负数49152, 0=正数32768)
                # 位14-7: 重复次数 (i)
                # 位6-0: 绝对值 (a)
                o.append((49152 if s < 0 else 32768) | (i << 7) | a)
            else:
                o.append(s)

            r += i

        e = o

        # 第三步：变长编码
        r = []  # 存储每个数字的十六进制位数
        o = []  # 存储实际数值

        for val in e:
            # 计算需要多少个十六进制位（每位4 bit）
            if val == 0:
                bits = 1
            else:
                # 方法1：使用对数（与原JS一致）
                bits = math.ceil(math.log(abs(val) + 1) / math.log(16))
                # 方法2：直接计算（更快）
                # bits = len(format(abs(val), 'x'))

                bits = max(1, bits)

            r.append(h(bits - 1, 2))  # 2位十六进制存储位数信息
            o.append(h(abs(val), 4 * bits))  # 实际值

        i = "".join(r)  # 元数据
        s = "".join(o)  # 数据

        # 第四步：符号位编码（仅用于坐标数据）
        if t:
            # 过滤掉：0值 和 已编码符号的压缩值（位15=1）
            filtered = [x for x in e if x != 0 and (x >> 15) != 1]
            n = "".join(["1" if x < 0 else "0" for x in filtered])
        else:
            n = ""

        # 最终格式：[头部16位][元数据][数据][符号位]
        # 头部：最高位置1 + 数组长度
        return h(32768 | len(e), 16) + i + s + n

    # 主函数：数据分离
    t = []  # 事件类型
    n = []  # 时间差
    r = []  # X坐标
    o = []  # Y坐标

    for i in range(len(e)):
        a = e[i]
        length = len(a)

        t.append(a[0])
        n.append(a[1] if length == 2 else a[2])

        if length == 3:
            r.append(a[1][0])
            o.append(a[1][1])

    # 压缩各部分
    c_str = f(t) + d(n, False) + d(r, True) + d(o, True)

    # 填充到6的倍数
    l = len(c_str)
    if l % 6 != 0:
        c_str += h(0, 6 - l % 6)

    # Base64编码
    def u(e):
        """Base64编码"""
        t = ""
        n = len(e) // 6
        base64_chars = (
            "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"
        )

        for r in range(n):
            # 每次取6位二进制
            binary_str = e[6 * r : 6 * (r + 1)]
            index = int(binary_str, 2)
            t += base64_chars[index]

        return t

    return u(c_str)


class TrajectoryEncoder:
    def __init__(self) -> None:
        self.CHARSET = (
            "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr"
        )
        self.BASE = len(self.CHARSET)  # 64
        self.DIRECTION_CHARS = "stuvwxyz~"
        self.DIRECTION_PATTERNS = [
            [1, 0],  # s
            [2, 0],  # t
            [1, -1],  # u
            [1, 1],  # v
            [0, 1],  # w
            [0, -1],  # x
            [3, 0],  # y
            [2, -1],  # z
            [2, 1],  # ~
        ]

    def encode_number(self, num):
        """编码单个数值为64进制"""
        abs_num = abs(num)
        high_index = abs_num // self.BASE
        low_index = abs_num % self.BASE

        result = ""

        # 负数标记
        if num < 0:
            result += "!"

        # 高位（当值>=64时）
        if high_index > 0 and high_index < self.BASE:
            result += "$"
            result += self.CHARSET[high_index]

        # 低位
        result += self.CHARSET[low_index]

        return result

    def compress_trajectory(self, points):
        """压缩轨迹：计算相邻点差值"""
        compressed = []
        time_accumulator = 0

        for i in range(len(points) - 1):
            dx = points[i + 1][0] - points[i][0]  # 不要用abs
            dy = points[i + 1][1] - points[i][1]  # 不要用abs
            dt = abs(points[i + 1][2] - points[i][2])  # 时间可以用abs

            # 跳过完全相同的点
            if dx == 0 and dy == 0 and dt == 0:
                continue

            # 位置不变只累积时间
            if dx == 0 and dy == 0:
                time_accumulator += dt
            else:
                compressed.append([dx, dy, dt + time_accumulator])
                time_accumulator = 0

        # 处理剩余时间
        if time_accumulator != 0:
            compressed.append([0, 0, time_accumulator])

        return compressed

    def get_direction_code(self, dx, dy):
        """识别是否匹配方向模式"""
        for i, pattern in enumerate(self.DIRECTION_PATTERNS):
            if dx == pattern[0] and dy == pattern[1]:
                return self.DIRECTION_CHARS[i]
        return None

    def encode(self, trajectory):
        """
        编码轨迹
        trajectory: [[x, y, timestamp], ...]
        返回: 编码后的字符串
        """
        compressed = self.compress_trajectory(trajectory)

        x_encoded = []
        y_encoded = []
        t_encoded = []

        for dx, dy, dt in compressed:
            direction_code = self.get_direction_code(dx, dy)

            if direction_code:
                # 匹配到方向模式，只记录y
                y_encoded.append(direction_code)
            else:
                # 不匹配，完整编码x和y
                x_encoded.append(self.encode_number(dx))
                y_encoded.append(self.encode_number(dy))

            # 时间总是编码
            t_encoded.append(self.encode_number(dt))

        # 拼接：x坐标 !! y坐标 !! 时间戳
        return (
            "".join(x_encoded) + "!!" + "".join(y_encoded) + "!!" + "".join(t_encoded)
        )

    def encrypt_string(self, e, t, n):
        """
        JS加密函数的Python实现

        参数:
        e: 原始字符串
        t: 加密参数数组
        n: 十六进制字符串
        """
        if not t or not n:
            return e

        o = 0  # 偏移量
        i = e  # 结果字符串
        s = t[0]  # 12
        a = t[2]  # 98
        _ = t[4]  # 43

        # 每次读取2个字符（十六进制）
        while o < len(n):
            r = n[o : o + 2]  # 取2个字符
            if len(r) < 2:
                break
            o += 2

            # 解析十六进制
            c = int(r, 16)

            # 转换为字符
            l = chr(c)

            # 计算插入位置: (s * c^2 + a * c + _) % len(e)
            u = (s * c * c + a * c + _) % len(e)

            # 在位置u插入字符
            i = i[:u] + l + i[u:]

        return i


def H(t: int, e: str) -> str:
    # 解析后缀
    n = e[-2:]
    r = []
    for char in n:
        o = ord(char)
        r.append(o - 87 if o > 57 else o - 48)
    n = 36 * r[0] + r[1]

    # 计算目标值
    a = round(t) + n

    # 构建字符池
    _ = [[], [], [], [], []]
    c = {}
    u = 0
    for char in e[:-2]:
        if char not in c:
            c[char] = 1
            _[u].append(char)
            u = (u + 1) % 5

    # 生成结果
    f = a
    d = 4
    p = ""
    g = [1, 2, 5, 10, 50]

    while f > 0:
        if f >= g[d]:
            h = int(random.random() * len(_[d]))
            p += _[d][h]
            f -= g[d]
        else:
            _.pop(d)
            g.pop(d)
            d -= 1

    return p