import base64
import zlib
import struct

from api.core.Redis import get_redis_info
from api.utils.skill_tree import SKILL_TREE_MAP_VERSION, load_skill_tree_map
from core.character.adventure import get_adv_info
from database.connect import get_redis_client

role_map = {
    # swordman_male
    '0': 0,
    # fighter_female
    '1': 3,
    # gunner_male
    '2': 4,
    # mage_female
    '3': 7,
    # priest_male
    '4': 8,
    # gunner_female
    '5': 5,
    # thief
    '6': 10,
    # fighter_male
    '7': 2,
    # mage_male
    '8': 6,
    # 黑暗武士
    '9': 15,
    # 缔造者
    '10': 15,
    # swordman_female
    '11': 1,
    # knight
    '12': 11,
    # demonic_lancer
    '13': 12,
    # priest_female
    '14': 9,
    # gunblader
    '15': 13,
    # archer
    '16': 14,
    # imperialknight
    '17': 16,
}


def decode_skill_hash(encoded: str) -> dict:
    """
    解码 DNF 技能加点编码，并根据职业技能树补充自动学习技能。

    输入 encoded 为游戏导出的 Base64 加点字符串。
    解码流程: base64 -> zlib decompress -> 二进制
    二进制结构:
      [Header 14B，首字节 0xF3] [UTF-16LE 角色名]
      [Section1: N个(技能索引,等级)对]
      [Section2: 进化 | 强化 | 键位 | 职业排列及其他尾部数据]

    Section1 中每个 uint16 的高字节=数据值，低字节=标志位。
    技能索引在 level_flag 非零时加 0x100。
    Section2 按字节读取，各子结构由数量字段和对应数量的定长条目组成；
    其中技能索引为低字节加 0x100（第二字节标志非零时）。

    所有职业均返回:
      header: 角色名、等级、职业字节、编码版本等头信息。
      skills: 原始加点列表，每项包含 skill_index、level、skill_flag、
              level_flag；不将自动学习技能混入此列表。
      auto_skills: 技能树中具有 autoLevel 且未出现在 skills 中的技能，
                   每项为 {skill_index, level}，等级直接取 autoLevel。
                   不覆盖显式加点，无补充项时为 []。
      evolutions: 进化列表，每项为 {skill_index, flag, type}，type 从 1 开始。
      enhancements: 强化列表，字段与 evolutions 相同。
      keybinds: 快捷栏列表，每项为 {slot, skill_index, flag}；
                slot 从 0 开始，空槽的 skill_index 为 None。
      section2_remaining: 快捷栏之后的完整原始字节，不因扩展解析而截断。
                          若角色名之后的数据长度为奇数，末尾含对齐补入的 0x00。
      raw_size: zlib 解压后的原始字节数，不包含解析器补入的对齐字节。

    按职业和版本额外返回:
      arrangements: 仅黑暗武士返回，格式为 [{slot_index, skills}]，
                    skills 保留该排列内技能索引的顺序。
      skill_combo: 仅版本 5 的非黑暗武士返回，格式为
                   {skills: [309, 305, 312, 311], interval_ms: 5000}。
                   skills 为四个有序槽位，空槽为 None；interval_ms 为
                   初始化间隔（毫秒）。读取 remaining[92:100] 的技能索引
                   和 remaining[100:102] 的小端 uint16 间隔；长度不足或
                   remaining[102] 不是 0xF3 时返回 None。
                   remaining[91] 含义未确认，不解释为数量或开关。

    未确认的尾部字段仅保留原始字节；黑暗武士不套用普通职业连招偏移。
    """
    raw = zlib.decompress(base64.b64decode(encoded))
    header = _parse_header(raw)

    data = raw[14 + header['name_byte_len'] :]
    if len(data) % 2:
        data += b'\x00'

    uint16s = [struct.unpack_from('<H', data, i)[0] for i in range(0, len(data), 2)]
    high = [v >> 8 for v in uint16s]
    low = [v & 0xFF for v in uint16s]

    num_pairs = high[0]
    skills = []
    for p in range(num_pairs):
        i = 1 + p * 2
        if i + 1 >= len(high):
            break
        skills.append(
            {
                'skill_index': high[i] + 0x100 if low[i + 1] else high[i],
                'level': high[i + 1],
                'skill_flag': low[i],
                'level_flag': low[i + 1],
            }
        )

    sec2_bytes = data[(1 + num_pairs * 2) * 2 :]
    evolutions, enhancements, keybinds, remaining = _parse_section2(sec2_bytes)

    result = {
        'header': header,
        'skills': skills,
        'evolutions': evolutions,
        'enhancements': enhancements,
        'keybinds': keybinds,
        'section2_remaining': remaining,
        'raw_size': len(raw),
    }
    # 黑暗武士才有技能排列；其他职业保持原有返回结构不变。
    if header['job_bytes'][0] == 9:
        result['arrangements'] = _parse_dark_knight_arrangements(remaining)
    elif header['version'] == 5:
        # 普通职业的技能连招与黑暗武士排列是两种结构，不能共用偏移。
        result['skill_combo'] = _parse_skill_combo(remaining)
    _, skill_tree = _get_skill_tree_context(header)
    encoded_ids = {str(skill['skill_index']) for skill in skills}
    result['auto_skills'] = [
        {'skill_index': int(skill_id), 'level': metadata['autoLevel']}
        for skill_id, metadata in skill_tree.items()
        if 'autoLevel' in metadata and skill_id not in encoded_ids
    ]
    return result


def _parse_header(raw: bytes) -> dict:
    nlen = raw[13]
    return {
        'magic': raw[0],
        'version': raw[1],
        'job_bytes': (raw[2], raw[3]),
        'level': raw[5],
        'job_marker': chr(raw[8]),
        'name': raw[14 : 14 + nlen].decode('utf-16-le'),
        'name_byte_len': nlen,
    }


def _parse_section2(sec2: bytes):
    """
    Section2 子结构:
      byte[0]:  标记位
      byte[1]:  进化数量 E
      byte[2..2+3E-1]:  E 个进化条目，每条 3 字节 (技能索引, 标志, 类型-1)
      byte[2+3E]:  强化数量 H
      byte[2+3E+1..2+3E+3H]:  H 个强化条目，每条 3 字节
      byte[2+3E+3H+1]:  键位数量 K (固定 0x0E=14)
      byte[..+2K]:  K 个键位条目，每条 2 字节 (技能索引, 标志)
      剩余: remaining = sec2[off:]，包含职业排列、技能连招及未解析数据。

    技能连招位于快捷栏之后的 remaining 中，不属于上面的 K 个键位条目。
    版本 5 普通职业（不含黑暗武士）的已确认布局如下，偏移从 remaining
    开头计算，不是从 sec2 或整个解压数据开头计算：
      remaining[91]:       含义未确认，不解释为数量或开关。
      remaining[92:100]:   四个有序连招技能，每项 2 字节；索引为低字节
                           加 0x100（第二字节非零时），0 表示空槽。
      remaining[100:102]:  初始化间隔，小端 uint16，单位毫秒。
      remaining[102]:      尾部标记 0xF3，其后可能有解析器补入的对齐 0x00。

    本函数仅返回完整 remaining，不直接解析连招；decode_skill_hash()
    根据职业和版本调用 _parse_skill_combo()，输出 skill_combo。
    黑暗武士的 remaining 前缀由 _parse_dark_knight_arrangements() 解析，
    不套用上述普通职业偏移。任何扩展解析均不截断原始 remaining。
    """
    if len(sec2) < 2:
        return [], [], [], sec2

    off = 0
    off += 1  # byte[0]: marker

    evo_count = sec2[off]
    off += 1
    evolutions = []
    for _ in range(evo_count):
        if off + 3 > len(sec2):
            break
        evolutions.append(
            {
                'skill_index': sec2[off] + 0x100 if sec2[off + 1] else sec2[off],
                'flag': sec2[off + 1],
                'type': sec2[off + 2] + 1,
            }
        )
        off += 3

    if off >= len(sec2):
        return evolutions, [], [], b''

    enh_count = sec2[off]
    off += 1
    enhancements = []
    for _ in range(enh_count):
        if off + 3 > len(sec2):
            break
        enhancements.append(
            {
                'skill_index': sec2[off] + 0x100 if sec2[off + 1] else sec2[off],
                'flag': sec2[off + 1],
                'type': sec2[off + 2] + 1,
            }
        )
        off += 3

    if off >= len(sec2):
        return evolutions, enhancements, [], b''

    key_count = sec2[off]
    off += 1
    keybinds = []
    for slot in range(key_count):
        if off + 2 > len(sec2):
            break
        idx = sec2[off] + 0x100 if sec2[off + 1] else sec2[off]
        flag = sec2[off + 1]
        keybinds.append(
            {
                'slot': slot,
                'skill_index': idx if idx != 0 else None,
                'flag': flag,
            }
        )
        off += 2

    remaining = sec2[off:]
    return evolutions, enhancements, keybinds, remaining


def _parse_skill_combo(remaining: bytes) -> dict | None:
    """读取版本 5 普通职业尾部的技能连招，不修改 remaining。

    已通过女蓝拳顺序确认及仅将间隔从 0 秒改为 5 秒的代码验证：
      remaining[92:100]：四个技能索引，每个 2 字节，0 表示空槽；
      remaining[100:102]：小端 uint16 初始化间隔，单位毫秒；
      remaining[102]：尾部 0xF3，解析器可能在它后面补齐一个 0x00。
    remaining[91] 的含义尚未确认，不将其解释为数量或开关。
    数据不足或尾部标记不匹配时返回 None，避免把未知布局当成空连招。
    """
    if len(remaining) < 103 or remaining[102] != 0xF3:
        return None

    skills = []
    for offset in range(92, 100, 2):
        # 与快捷栏一致：低字节为索引，第二字节非零表示加 0x100。
        index = remaining[offset] + (0x100 if remaining[offset + 1] else 0)
        skills.append(index if index else None)
    return {
        'skills': skills,
        'interval_ms': struct.unpack_from('<H', remaining, 100)[0],
    }


def _parse_dark_knight_arrangements(remaining: bytes) -> list[dict]:
    """从原始 remaining 前缀中读取黑暗武士技能排列。

    黑暗武士的排列格式为：排列组数(1B)，随后每组依次存储
    排列槽索引(2B)、组内技能数(1B)和对应数量的技能索引(2B)。

    本函数只读取已确认的排列前缀，不解析或截断排列后的未知数据；
    decode_skill_hash 仍按原格式返回完整的 section2_remaining。
    """
    if not remaining:
        return []

    arrangement_count = remaining[0]
    off = 1
    arrangements = []
    for _ in range(arrangement_count):
        if off + 3 > len(remaining):
            break

        slot_index = remaining[off] + 0x100 if remaining[off + 1] else remaining[off]
        off += 2
        skill_count = remaining[off]
        off += 1
        if off + skill_count * 2 > len(remaining):
            break

        skills = []
        for _ in range(skill_count):
            skill_index = remaining[off] + 0x100 if remaining[off + 1] else remaining[off]
            skills.append(skill_index)
            off += 2

        arrangements.append(
            {
                'slot_index': slot_index,
                'skills': skills,
            }
        )

    return arrangements


def resolve_skill_tree(decoded: dict, skill_tree: dict[str, dict]) -> dict:
    """将二进制结果映射到 OpenAPI 技能 ID；不依赖角色计算对象。

    autoLevel 仅补充代码中缺失的技能，不覆盖显式等级。
    """
    skills = {}
    for item in decoded['skills'] + decoded['auto_skills']:
        skill_id = str(item['skill_index'])
        metadata = skill_tree.get(skill_id)
        if metadata is None:
            continue
        if skill_id not in skills or item['level'] > skills[skill_id]['lv']:
            skills[skill_id] = {
                'lv': item['level'], 'up': 0, 'vp': 0, 'name': metadata['name'],
            }
    for section, field in [('evolutions', 'vp'), ('enhancements', 'up')]:
        for item in decoded[section]:
            skill = skills.get(str(item['skill_index']))
            if skill is not None:
                skill[field] = item['type']

    def reference(skill_index):
        metadata = skill_tree.get(str(skill_index))
        return {
            'skill_id': skill_index if metadata is not None else None,
            'skill_name': metadata['name'] if metadata is not None else None,
        }

    return {
        'skills': skills,
        'shortcuts': [
            {'slot': item['slot'], **reference(item['skill_index'])}
            for item in decoded['keybinds']
        ],
        'combos': [
            {
                'slot_index': item['slot_index'],
                'skills': [reference(index) for index in item['skills']],
            }
            for item in decoded.get('arrangements', [])
        ],
    }


def _get_skill_tree_context(header: dict) -> tuple[dict, dict[str, dict]]:
    """根据编码职业读取 Redis 技能树缓存，未命中时回退本地文件。"""
    role = role_map.get(str(header['job_bytes'][0]), None)
    job_id = int(header['job_bytes'][1]) - 1
    # 黑暗武士
    if header['job_bytes'][0] == 9:
        job_id = 1
    # 缔造者
    if header['job_bytes'][0] == 10:
        job_id = 0
    id = base64.b64encode(f'{role:02}{job_id:02}00'.encode()).decode()
    advInfo = get_adv_info(id)
    className = advInfo['class']
    class_parts = className.split('.')
    job_name = class_parts[1]
    job_grow_name = class_parts[2].replace('_carry', '')

    with get_redis_client() as redis:
        skill_tree = get_redis_info(
            redis,
            f'openapi:{SKILL_TREE_MAP_VERSION}:{job_name}:{job_grow_name}:map',
            lambda: load_skill_tree_map(job_name, job_grow_name),
        )
    return advInfo, skill_tree


def get_openapi_skill_tree_info(encoded: str) -> dict:
    """解析并补全技能树，返回 OpenAPI 技能 ID，不创建计算角色。"""
    r = decode_skill_hash(encoded)
    header = r['header']
    advInfo, skill_tree = _get_skill_tree_context(header)
    return {
        'name': header['name'],
        'level': header['level'],
        'job': advInfo,
        **resolve_skill_tree(r, skill_tree),
    }


def get_skill_tree_info(encoded: str) -> dict:
    """将完整 OpenAPI 加点映射为计算器技能 ID，保持现有接口格式。"""
    from core.basic.character import createCharacter

    info = get_openapi_skill_tree_info(encoded)
    character = createCharacter(info['job']['class'])
    skills_by_name = {}
    for skill in character.skills:
        skills_by_name.setdefault(skill.name, []).append(skill)

    skill_learn = {}
    for item in info['skills'].values():
        candidates = skills_by_name.get(item['name'], [])
        if not candidates:
            continue
        # 保持原有同名技能等级选首项、进化/强化排除觉醒分身的规则。
        chosen = candidates[0]
        chosen_id = str(chosen.id)
        if chosen_id not in skill_learn or skill_learn[chosen_id]['lv'] < item['lv']:
            skill_learn[chosen_id] = {**item, 'up': 0, 'vp': 0}
        targets = [s for s in candidates if s.learnLv not in [50, 85]] if len(candidates) > 1 else candidates
        for skill in targets:
            learned = skill_learn.get(str(skill.id))
            if learned is not None:
                if getattr(skill, 'hasVP', False):
                    learned['vp'] = item['vp']
                if getattr(skill, 'hasUP', False):
                    learned['up'] = item['up']

    for skill in character.skills:
        skill_learn.setdefault(str(skill.id), {
            'lv': skill.calculate_lv() if skill.name == '基础精通' else 0,
            'up': 0, 'vp': 0, 'name': skill.name,
        })

    def match_reference(item):
        candidates = skills_by_name.get(item['skill_name'], [])
        if len(candidates) > 1:
            candidates = [s for s in candidates if s.learnLv not in [50, 85]]
        return [{'skill_id': s.id, 'skill_name': s.name} for s in candidates]

    shortcuts = []
    for item in info['shortcuts']:
        matches = match_reference(item) or [{'skill_id': None, 'skill_name': None}]
        shortcuts.extend({'slot': item['slot'], **match} for match in matches)
    combos = [
        {
            'slot_index': combo['slot_index'],
            'skills': [match for item in combo['skills'] for match in match_reference(item)],
        }
        for combo in info['combos']
    ]
    return {**info, 'skills': skill_learn, 'shortcuts': shortcuts, 'combos': combos}


# def print_decoded(encoded: str):
#     """解码并打印技能编码的全部信息。"""
#     r = decode_skill_hash(encoded)
#     h = r['header']

#     print('=' * 70)
#     print('DNF 技能加点编码解析')
#     print('=' * 70)

#     print(f'\n【角色信息】')
#     print(f'  角色名:     {h["name"]}')
#     print(f'  等级:       {h["level"]}')
#     print(f'  职业字节:   ({int(h["job_bytes"][0])}, {int(h["job_bytes"][1])})')
#     print(f'  编码版本:   {h["version"]}')
#     print(f'  数据大小:   {r["raw_size"]} bytes')

#     print(f'\n  主动投入技能 (等级 > 1):')
#     for s in reversed(r['skills']):
#         f = ''
#         if s['skill_flag']:
#             f += f' sf={s["skill_flag"]}'
#         if s['level_flag']:
#             f += f' lf={s["level_flag"]}'
#         print(f'    技能 {int(s["skill_index"]):<5d}  Lv.{s["level"]:<3d}{f}')

#     print(f'\n【进化选择】({len(r["evolutions"])} 个)')
#     for e in r['evolutions']:
#         t = '选项一' if e['type'] == 1 else '选项二'
#         print(f'    技能 {int(e["skill_index"]):<5d}  {t}')

#     print(f'\n【强化选择】({len(r["enhancements"])} 个)')
#     for e in r['enhancements']:
#         t = f'类型{e["type"]}'
#         print(f'    技能 {int(e["skill_index"]):<5d}  {t}')

#     active = [k for k in r['keybinds'] if k['skill_index'] is not None]
#     print(f'\n【快捷键】({len(active)}/{len(r["keybinds"])} 槽位已使用)')
#     for k in r['keybinds']:
#         if k['skill_index'] is not None:
#             f = f' (flag={k["flag"]})' if k['flag'] else ''
#             print(f'    槽位 {k["slot"]:2d}: 技能 {int(k["skill_index"]):<5d}{f}')
#         else:
#             print(f'    槽位 {k["slot"]:2d}: (空)')