# -*- coding: utf-8 -*-
"""Xiangqi.com 在线对弈机器人核心(aiohttp 全异步, 协议要点见文末)。

    协议要点(实测):
    - REST 与 WS 均不带 Cookie; WS 握手必须带 Origin, 否则立即被关
    - 匹配: POST /api/v2/games/quick-challenge {"config_str":"10/2"}
    - 匹配成功后: lobby.left -> g_v2.get 入座
    - 走子: g_v2.move {game_id, move, thinking_time}; 回执 game.move.success
"""
import argparse
import asyncio
import base64
import json
import logging
import re
import ssl

import aiohttp

from .cloud import CloudBook
from .coords import fen_from_moves, site_to_ucci, ucci_to_site
from .pikafish import Pikafish

log = logging.getLogger('xiangqi.bot')

API = 'https://api.xiangqi.com/api'
WS_URL = 'wss://api.xiangqi.com/socket.io/?jwt={jwt}&EIO=4&transport=websocket'
NS = '/xiangqi'
FIRST_MOVE_EXTRA = 5  # 红方首步额外延迟秒数

END_REASONS = {100: '绝杀', 101: '困毙', 200: '超时', 300: '认输',
               400: '和棋', 401: '不吃子和', 402: '重复和', 500: '断线', 600: '弃局'}


def build_parser():
    p = argparse.ArgumentParser(description='Xiangqi.com 在线对弈 + 皮卡鱼 + 云库')
    p.add_argument('--game', help='接管已有对局 ID')
    p.add_argument('--strength', type=int, default=1000, help='每步思考毫秒')
    p.add_argument('--depth', type=int, default=None, help='固定深度(优先于 strength)')
    p.add_argument('--threads', type=int, default=None, help='线程数(默认=CPU核心数)')
    p.add_argument('--hash', type=int, default=256, help='哈希表 MB')
    p.add_argument('--config', default='10/2', help='匹配时制 总分钟/加秒')
    p.add_argument('--first-delay', type=int, default=0, help='红方首步延迟秒(实际=此值+5)')
    p.add_argument('--move-delay', type=float, default=1.0, help='每步最小间隔秒')
    p.add_argument('--cloud-min-score', type=int, default=15, help='云库采纳阈值(厘兵)')
    p.add_argument('--no-cloud', action='store_true', help='禁用云库')
    p.add_argument('--no-tui', action='store_true', help='不启用 TUI, 仅日志输出')
    return p


class OnlineBot:
    """对局机器人。状态字段(status/moves/fen/score 等)供 TUI 直接读取。"""

    def __init__(self, args):
        self.args = args
        self.session = None          # 惰性: 首个协程调用时创建(需事件循环)
        self.jwt = None
        self.engine = None
        self.cloud = CloudBook(min_score=args.cloud_min_score)
        self.ws = None
        self.game_id = None
        self.my_side = None          # 'red' | 'black'
        self.moves = []              # UCCI
        self.site_moves = []         # 站点坐标(展示用)
        self.fen = None
        self.score = None
        self.source = None           # 'cloud' | 'engine' | 'cloud(n候选)'
        self.status = '初始化'
        self.end_reason = None
        self.moves_count_opponent = 0
        self.paused = False
        self.game_over = False
        self.game_started = False
        self.thinking = False
        self._stop = False
        self.first_deadline = None
        self.last_move_at = 0.0
        self._ack = 0

    # ---------- 状态/控制接口(TUI 用) ----------
    @property
    def use_cloud(self):
        return not self.args.no_cloud

    def toggle_cloud(self):
        self.args.no_cloud = self.use_cloud

    def toggle_pause(self):
        self.paused = not self.paused
        log.info('[bot] %s', '已暂停' if self.paused else '继续')
        return self.paused

    async def new_match(self):
        """弃掉当前对局并重新匹配。"""
        if self.game_id and not self.game_over:
            try:
                await self.emit('g_v2.abandon', {'game_id': self.game_id,
                                                 'abandonmentSource': 'timeout'})
            except Exception:
                pass
        self.game_over = True
        await asyncio.sleep(1)
        self.game_over = False
        self.game_started = False
        self.game_id = None
        self.my_side = None
        self.moves.clear()
        self.site_moves.clear()
        self.fen = None
        self.score = self.source = None
        self.end_reason = None
        self.first_deadline = None
        self.status = '重新匹配中…'
        await self.quick_challenge()

    # ---------- 生命周期 ----------
    async def _get_session(self):
        if self.session is None or self.session.closed:
            self.session = aiohttp.ClientSession()
        return self.session

    async def run(self, on_ready=None):
        session = await self._get_session()
        async with session.post(f'{API}/users/guest_jwt',
                                     timeout=aiohttp.ClientTimeout(10)) as r:
            r.raise_for_status()
            self.jwt = (await r.json()).get('jwt')
        log.info('[auth] guest JWT %s...', self.jwt[:24])

        self.engine = await Pikafish(
            threads=self.args.threads, hash_mb=self.args.hash,
            movetime=self.args.strength).start()
        log.info('[engine] threads=%s hash=%sMB', self.engine.threads, self.args.hash)

        origin = 'https://play.xiangqi.com'
        async with self.session.ws_connect(
                WS_URL.format(jwt=self.jwt), origin=origin,
                autoping=True, heartbeat=20) as ws:
            self.ws = ws
            log.info('[ws] connected')
            self.status = '已连接, 匹配中…'
            if on_ready:
                on_ready(self)
            async for msg in ws:
                if msg.type == aiohttp.WSMsgType.TEXT:
                    await self.on_frame(msg.data)
                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
                    break
                if self._stop:
                    break
        self.status = '连接断开'

    async def close(self):
        self._stop = True
        self.game_over = True
        await self.cloud.close()
        if self.engine:
            await self.engine.quit()
        await self.session.close()

    # ---------- 协议 ----------
    async def emit(self, event, data, ack=False):
        self._ack += 1
        n = self._ack if ack else ''
        payload = json.dumps([event, data], ensure_ascii=False)
        await self.ws.send_str(f'42{NS},{n}{payload}')

    def my_name(self):
        try:
            payload = self.jwt.split('.')[1]
            payload += '=' * (4 - len(payload) % 4)
            return json.loads(base64.urlsafe_b64decode(payload)).get('sub')
        except Exception:
            return None

    async def on_frame(self, raw):
        if raw == '2':
            await self.ws.send_str('3')
            return
        if raw.startswith('0'):
            await self.ws.send_str(f'40{NS},' + json.dumps({'token': self.jwt}))
            return
        if raw.startswith('40'):
            log.info('[ws] joined /xiangqi')
            await self.emit('lobby.join', {'room': 'lobby'})
            if not self.args.game:
                await asyncio.sleep(1)
                await self.quick_challenge()
            return
        if not raw.startswith(f'42{NS},'):
            return
        m = re.match(rf'^42{NS},(\d+)?(\[.*\])$', raw, re.DOTALL)
        if not m:
            return
        try:
            arr = json.loads(m.group(2))
        except json.JSONDecodeError:
            return
        await self.on_event(arr[0], arr[1] if len(arr) > 1 else {})

    async def on_event(self, event, data):
        if event == 'lobby.my.game.new':
            self.game_id = data.get('game_id')
            self.status = f'已匹配 {self.game_id}'
            log.info('[game] matched %s', self.game_id)
            await self.emit('lobby.left', {})
            await asyncio.sleep(0.3)
            await self.emit('g_v2.get', {'game_id': self.game_id}, ack=True)
        elif event == 'game.get.success':
            d = data.get('data', {})
            me = self.my_name()
            for p, side in ((d.get('rplayer', {}), 'red'), (d.get('bplayer', {}), 'black')):
                if p.get('username') == me or p.get('identity') == me:
                    self.my_side = side
                    break
            self.moves = [site_to_ucci(str(x.get('move', x)).split()[0])
                          for x in d.get('move_history', [])]
            self.site_moves = [ucci_to_site(m) for m in self.moves]
            self.fen = d.get('fen') or fen_from_moves(self.moves)
            self.game_started = True
            self.status = f'对局中({len(self.moves)} 步)'
            log.info('[game] %s 我方=%s, 已 %d 步', self.game_id, self.my_side, len(self.moves))
            asyncio.create_task(self.maybe_move())
        elif event == 'game.start.success':
            self.game_over = False
            self.game_started = True
            self.first_deadline = None
            asyncio.create_task(self.maybe_move())
        elif event == 'game.move.opponent':
            d = data.get('data') or {}
            mv = str(d.get('move', '')).split()[0]
            if d.get('fen'):
                self.fen = d['fen']
            if mv:
                ucci = site_to_ucci(mv)
                if not self.moves or self.moves[-1] != ucci:
                    self.moves.append(ucci)
                    self.site_moves.append(mv)
                    self.fen = d.get('fen') or fen_from_moves(self.moves)
                    log.info('[game] 对手 %s (%d 步)', mv, len(self.moves))
                    asyncio.create_task(self.maybe_move())
        elif event == 'game.move.success':
            self.thinking = False
        elif event == 'game.server.end':
            d = data.get('data') or {}
            self.end_reason = d.get('end_reason')
            res = d.get('end_result') or {}
            self.status = f'对局结束: {END_REASONS.get(self.end_reason, self.end_reason)}'
            log.info('[game] 结束: %s (%s)', self.status,
                     json.dumps(res, ensure_ascii=False)[:120])
            self.game_over = True
            self.thinking = False
        elif event == 'game.error':
            log.warning('[game.error] %s', json.dumps(data, ensure_ascii=False)[:200])

    async def quick_challenge(self):
        self.status = '匹配中…'
        session = await self._get_session()
        async with session.post(
                f'{API}/v2/games/quick-challenge',
                headers={'Authorization': f'Bearer {self.jwt}'},
                json={'config_str': self.args.config}) as r:
            log.info('[match] %s %s', r.status, (await r.text())[:80])

    # ---------- 走子 ----------
    def is_my_turn(self):
        if not self.my_side or self.game_over or self.paused:
            return False
        return (len(self.moves) % 2 == 0) == (self.my_side == 'red')

    async def maybe_move(self):
        if (self.thinking or self.game_over or not self.game_id
                or not self.my_side or self.paused):
            return
        if not self.is_my_turn():
            return
        self.thinking = True
        try:
            if not self.moves and self.my_side == 'red' and self.args.first_delay:
                wait = self.args.first_delay + FIRST_MOVE_EXTRA
                self.status = f'红方首步延迟 {wait}s'
                log.info('[game] 红方首步延迟 %ds', wait)
                await asyncio.sleep(wait)
                if self.game_over or not self.is_my_turn():
                    return

            fen = fen_from_moves(self.moves)
            t0 = asyncio.get_event_loop().time()
            # 每步最小间隔(深度/云库秒回时保持节奏)
            if self.args.move_delay:
                gap = self.args.move_delay - (t0 - self.last_move_at)
                if gap > 0:
                    self.status = f'行棋节奏延迟 {gap:.0f}s'
                    log.info('[game] 行棋节奏延迟 %.1fs', gap)
                    await asyncio.sleep(gap)
                    if self.game_over or not self.is_my_turn():
                        return

            mv = score = None
            source = 'engine'

            if self.use_cloud:
                cloud = await self.cloud.best(fen, moves_count=len(self.moves))
                if cloud:
                    mv, score, source = cloud[0], f'cp {cloud[1]}', f'cloud({cloud[2]})'

            if mv is None:
                self.status = '皮卡鱼思考中…'
                mv, score = await self.engine.bestmove(
                    moves=self.moves, fen=fen,
                    movetime=self.args.strength, depth=self.args.depth)

            site_mv = ucci_to_site(mv)
            self.moves.append(mv)
            self.site_moves.append(site_mv)
            self.fen = fen_from_moves(self.moves)
            self.last_move_at = asyncio.get_event_loop().time()
            self.score, self.source = score, source
            self.status = f'已走 {site_mv}'
            think_ms = int((self.last_move_at - t0) * 1000)
            log.info('[game] %s: %s → %s  %s %dms', source, mv, site_mv, score, think_ms)
            await self.emit('g_v2.move', {'game_id': self.game_id, 'move': site_mv,
                                          'thinking_time': think_ms})
        except Exception as e:
            log.error('[move] %s: %s', type(e).__name__, e)
            if self.engine._proc.returncode is not None:
                await self.engine.restart()
        finally:
            self.thinking = False


async def async_main(args):
    bot = OnlineBot(args)
    try:
        await bot.run()
    finally:
        await bot.close()


def main():
    args = build_parser().parse_args()
    if not args.no_tui:
        from .tui import run_tui
        raise SystemExit(run_tui(args))
    try:
        asyncio.run(async_main(args))
    except KeyboardInterrupt:
        pass


if __name__ == '__main__':
    main()