"""Bounded, synchronous, uncompressed policy transport for hybrid evaluation.

There is deliberately no reconnect/retry path: a lost connection invalidates the
current rollout. Session/sequence checks protect against executing stale actions.
"""
import asyncio
import hashlib
import http
import json
import math
from pathlib import Path
import socket
import sys
import threading
import time
import uuid

import numpy as np

UPSTREAM = Path(__file__).resolve().parents[1] / 'third_party/lingbot-vla-v2'
if str(UPSTREAM) not in sys.path:
    sys.path.insert(0, str(UPSTREAM))
from deploy.msgpack_numpy import Packer, unpackb

PROTOCOL = 'hybrid_v1'


class InfrastructureError(RuntimeError):
    """Abort this episode; restarting requires restoring the complete scene."""


def append_record(path, value):
    if path is not None:
        path = Path(path)
        path.parent.mkdir(parents=True, exist_ok=True)
        with path.open('a') as stream:
            stream.write(json.dumps(value, sort_keys=True) + '\n')
            stream.flush()


def noise_sha256(noise):
    return hashlib.sha256(np.ascontiguousarray(noise).tobytes()).hexdigest()


def generate_noise(policy_seed, sequence_id, shape):
    """Canonical CPU float32 noise; this is an explicitly new RNG protocol."""
    rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence(
        [int(policy_seed), int(sequence_id)])))
    return rng.standard_normal(tuple(shape), dtype=np.float32)


def validate_noise(noise, shape):
    if not isinstance(noise, np.ndarray) or noise.dtype != np.float32:
        raise InfrastructureError('Noise must be a CPU float32 NumPy array')
    if tuple(noise.shape) != tuple(shape) or not np.isfinite(noise).all():
        raise InfrastructureError('Invalid noise shape or nonfinite noise')
    return np.ascontiguousarray(noise)


def infer_with_noise(policy, observation, noise, torch_module=None):
    """Inject noise through the upstream API without changing upstream files."""
    if noise is None:
        return policy.infer(observation)
    if torch_module is None:
        import torch as torch_module
    original = policy.sample_actions_fn
    calls = 0

    def sample(*args, **kwargs):
        nonlocal calls
        calls += 1
        if calls != 1 or kwargs.get('noise') is not None:
            raise InfrastructureError('Expected exactly one upstream noise injection')
        state = args[4] if len(args) > 4 else kwargs['state']
        # Upstream updates x_t=noise in place. Clone even after device conversion.
        tensor = torch_module.from_numpy(noise.copy()).to(
            device=state.device, dtype=state.dtype).clone()
        kwargs['noise'] = tensor
        return original(*args, **kwargs)

    policy.sample_actions_fn = sample
    try:
        result = policy.infer(observation)
        if calls != 1:
            raise InfrastructureError('The policy did not consume explicit noise')
        return result
    finally:
        policy.sample_actions_fn = original


class ProtocolSession:
    """One connection owns one policy; completed request IDs are idempotent."""
    def __init__(self, infer, noise_shape, synchronize=lambda: None):
        self.infer = infer
        self.noise_shape = tuple(noise_shape)
        self.synchronize = synchronize
        self.session_id = None
        self.episode_id = None
        self.sequence_id = -1
        self.cache = {}
        self.seen_sessions = set()

    def process(self, request, digest):
        if not isinstance(request, dict) or request.get('protocol') != PROTOCOL:
            raise InfrastructureError('Unsupported hybrid protocol')
        session = request.get('session_id')
        episode = request.get('episode_id')
        sequence = request.get('sequence_id')
        if (not isinstance(session, str) or not 1 <= len(session) <= 128 or
                not isinstance(episode, str) or not 1 <= len(episode) <= 256 or
                type(sequence) is not int or sequence < 0):
            raise InfrastructureError('Invalid request identity')
        operation = request.get('operation')
        if session == self.session_id and sequence in self.cache:
            cached_hash, cached_response = self.cache[sequence]
            if episode != self.episode_id or digest != cached_hash:
                raise InfrastructureError('Reused sequence has different payload or episode')
            return cached_response, True
        if operation == 'reset':
            seed = request.get('policy_seed')
            if (sequence != 0 or session in self.seen_sessions or
                    type(seed) is not int or not 0 <= seed < 2**32):
                raise InfrastructureError('A new episode requires a new session and sequence zero')
            observation = {'reset': True, 'robo_name': 'robotwin', 'policy_seed': seed}
            noise = None
        elif operation == 'infer':
            if (session != self.session_id or episode != self.episode_id or
                    sequence != self.sequence_id + 1):
                raise InfrastructureError('Missing reset, stale session, or out-of-order request')
            observation = request.get('observation')
            if not isinstance(observation, dict) or observation.get('reset'):
                raise InfrastructureError('Invalid inference observation')
            noise = validate_noise(request.get('noise'), self.noise_shape)
        else:
            raise InfrastructureError('Unsupported operation')
        self.synchronize()
        started = time.perf_counter()
        action = self.infer(observation, noise)
        self.synchronize()
        infer_ms = (time.perf_counter() - started) * 1000
        if not isinstance(action, dict):
            raise InfrastructureError('Policy returned an invalid response')
        response = {'protocol': PROTOCOL, 'session_id': session,
                    'episode_id': episode, 'sequence_id': sequence,
                    'request_sha256': digest, 'result': action,
                    'server_infer_ms': infer_ms,
                    'noise_sha256': noise_sha256(noise) if noise is not None else None}
        if operation == 'reset':
            self.session_id, self.episode_id = session, episode
            self.cache = {}
            self.seen_sessions.add(session)
        self.sequence_id = sequence
        self.cache[sequence] = (digest, response)
        return response, False


class HybridPolicyServer:
    def __init__(self, policy, host='127.0.0.1', port=None, metadata=None,
                 log_path=None, synchronize=None, hardware=None):
        if host != '127.0.0.1':
            raise ValueError('Hybrid server must bind to loopback; use an SSH tunnel')
        self.policy, self.host, self.port = policy, host, port
        self.log_path = log_path
        self.noise_shape = (1, policy.config.n_action_steps, policy.config.max_action_dim)
        if synchronize is None:
            import torch
            synchronize = torch.cuda.synchronize
            properties = torch.cuda.get_device_properties(torch.cuda.current_device())
            hardware = {'gpu_name': properties.name,
                        'gpu_memory_bytes': properties.total_memory,
                        'gpu_capability': list(torch.cuda.get_device_capability()),
                        'gpu_uuid': str(getattr(properties, 'uuid', 'unavailable')),
                        'torch_version': torch.__version__, 'cuda_version': torch.version.cuda}
        self.synchronize = synchronize
        self.metadata = {**(metadata or {}), **(hardware or {}),
                         'protocol': PROTOCOL, 'evaluation_protocol': PROTOCOL,
                         'noise_shape': list(self.noise_shape),
                         'noise_protocol': 'numpy_PCG64_SeedSequence_policy_seed_sequence_float32',
                         'transport_compression': None, 'reconnect_policy': 'abort_episode'}
        self._active = False

    def serve_forever(self):
        asyncio.run(self.run())

    async def run(self):
        from websockets.asyncio.server import serve
        async with serve(self._handler, self.host, self.port, compression=None,
                         max_size=None, ping_interval=None, process_request=self._health_check) as server:
            await server.serve_forever()

    @staticmethod
    def _health_check(connection, request):
        if request.path == '/healthz':
            return connection.respond(http.HTTPStatus.OK, 'OK\n')

    async def _handler(self, websocket):
        from websockets.exceptions import ConnectionClosed
        packer = Packer()
        if self._active:
            await websocket.close(code=1013, reason='A policy client already owns this server')
            return
        self._active = True
        session = ProtocolSession(
            lambda observation, noise: infer_with_noise(self.policy, observation, noise),
            self.noise_shape, self.synchronize)
        try:
            await websocket.send(packer.pack(self.metadata))
            while True:
                raw = await websocket.recv()
                if not isinstance(raw, bytes):
                    raise InfrastructureError('Expected a binary request')
                started = time.perf_counter()
                request = unpackb(raw)
                unpack_ms = (time.perf_counter() - started) * 1000
                digest = hashlib.sha256(raw).hexdigest()
                response, duplicate = session.process(request, digest)
                started = time.perf_counter()
                payload = packer.pack(response)
                pack_ms = (time.perf_counter() - started) * 1000
                started = time.perf_counter()
                await websocket.send(payload)
                send_ms = (time.perf_counter() - started) * 1000
                append_record(self.log_path, {
                    'timestamp': time.time(), 'session_id': response['session_id'],
                    'episode_id': response['episode_id'], 'sequence_id': response['sequence_id'],
                    'operation': request['operation'], 'duplicate': duplicate,
                    'request_sha256': digest, 'noise_sha256': response['noise_sha256'],
                    'request_bytes': len(raw), 'response_bytes': len(payload),
                    'server_unpack_ms': unpack_ms, 'server_pack_ms': pack_ms,
                    'server_send_ms': send_ms, 'server_infer_ms': response['server_infer_ms']})
        except ConnectionClosed:
            pass
        except Exception as error:
            append_record(self.log_path, {'timestamp': time.time(),
                          'event': 'infrastructure_error', 'error': str(error)})
            try:
                await websocket.send(packer.pack({'protocol': PROTOCOL, 'error': str(error)}))
                await websocket.close(code=1011, reason='Episode invalidated')
            except ConnectionClosed:
                pass
        finally:
            self._active = False


class HybridClient:
    def __init__(self, host='127.0.0.1', port=9340, timeout=120,
                 log_path=None, _connection=None):
        if not 0 < timeout <= 120:
            raise ValueError('timeout must be in (0,120] seconds')
        from websockets.sync.client import connect
        self.timeout, self.log_path = timeout, log_path
        self._packer = Packer()
        self._ws = None
        self._broken = False
        self._session_id = self._episode_id = None
        self._sequence = 0
        self._seed = None
        self.metrics, self.last_metrics = [], None
        try:
            self._ws = _connection or connect(
                f'ws://{host}:{port}', compression=None, max_size=None,
                open_timeout=timeout, close_timeout=2, ping_interval=None)
            metadata = unpackb(self._ws.recv(timeout=timeout))
            if metadata.get('protocol') != PROTOCOL:
                raise InfrastructureError('Unexpected server protocol')
            shape = metadata.get('noise_shape')
            if not isinstance(shape, list) or len(shape) != 3 or any(type(x) is not int or x <= 0 for x in shape):
                raise InfrastructureError('Invalid server noise shape')
            self._metadata = metadata
        except Exception as error:
            self.close()
            raise InfrastructureError(f'Policy connection failed: {error}') from error

    def get_server_metadata(self):
        return dict(self._metadata)

    def reset(self, episode_id, policy_seed):
        if self._broken:
            raise InfrastructureError('Connection invalidated; restore scene and create a new client')
        self._session_id = uuid.uuid4().hex
        self._episode_id = str(episode_id)
        self._sequence, self._seed = 0, int(policy_seed)
        return self._request('reset', policy_seed=self._seed)

    def infer(self, observation, noise=None):
        if self._session_id is None:
            raise InfrastructureError('reset() is required before inference')
        sequence = self._sequence + 1
        if noise is None:
            noise = generate_noise(self._seed, sequence, self._metadata['noise_shape'])
        noise = validate_noise(noise, self._metadata['noise_shape'])
        self._sequence = sequence
        return self._request('infer', observation=observation, noise=noise)

    def _request(self, operation, **values):
        if self._broken or self._ws is None:
            raise InfrastructureError('Connection invalidated; no automatic retry is permitted')
        request = {'protocol': PROTOCOL, 'session_id': self._session_id,
                   'episode_id': self._episode_id, 'sequence_id': self._sequence,
                   'operation': operation, **values}
        started = time.perf_counter()
        raw = self._packer.pack(request)
        pack_ms = (time.perf_counter() - started) * 1000
        digest = hashlib.sha256(raw).hexdigest()
        started = time.perf_counter()
        # recv(timeout=...) alone cannot bound a blocked socket.sendall().
        # Closing the underlying socket from a timer bounds both phases.
        def abort_socket():
            connection_socket = getattr(self._ws, 'socket', None)
            if connection_socket is not None:
                try:
                    connection_socket.shutdown(socket.SHUT_RDWR)
                except OSError:
                    pass
                connection_socket.close()
        watchdog = threading.Timer(self.timeout, abort_socket)
        watchdog.daemon = True
        watchdog.start()
        try:
            self._ws.send(raw)
            remaining = self.timeout - (time.perf_counter() - started)
            if remaining <= 0:
                raise TimeoutError('Policy request deadline expired during send')
            response_raw = self._ws.recv(timeout=remaining)
            rtt_ms = (time.perf_counter() - started) * 1000
            if not isinstance(response_raw, bytes):
                raise InfrastructureError('Expected a binary response')
            started = time.perf_counter()
            response = unpackb(response_raw)
            unpack_ms = (time.perf_counter() - started) * 1000
            if response.get('error'):
                raise InfrastructureError(response['error'])
            for key in ('protocol', 'session_id', 'episode_id', 'sequence_id'):
                if response.get(key) != request[key]:
                    raise InfrastructureError(f'Response identity mismatch: {key}')
            if response.get('request_sha256') != digest:
                raise InfrastructureError('Response request hash mismatch')
            noise_hash = noise_sha256(values['noise']) if 'noise' in values else None
            if response.get('noise_sha256') != noise_hash:
                raise InfrastructureError('Response noise hash mismatch')
            if not isinstance(response.get('result'), dict):
                raise InfrastructureError('Invalid policy result')
            for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms'):
                if key in response and (type(response[key]) not in (int, float) or
                                        not math.isfinite(response[key]) or response[key] < 0):
                    raise InfrastructureError('Invalid server timing: ' + key)
        except Exception as error:
            self._broken = True
            self.close()
            raise InfrastructureError(f'Policy request failed; episode must restart: {error}') from error
        finally:
            watchdog.cancel()
        metric = {'timestamp': time.time(), 'session_id': self._session_id,
                  'episode_id': self._episode_id, 'sequence_id': self._sequence,
                  'operation': operation, 'request_sha256': digest,
                  'noise_sha256': noise_hash, 'client_pack_ms': pack_ms,
                  'client_rtt_ms': rtt_ms, 'client_unpack_ms': unpack_ms,
                  'request_bytes': len(raw), 'response_bytes': len(response_raw),
                  'server_infer_ms': response['server_infer_ms']}
        for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms',
                    'server_fifo_index', 'server_pending_at_enqueue', 'concurrency_protocol'):
            if key in response:
                metric[key] = response[key]
        self.last_metrics = metric
        self.metrics.append(metric)
        append_record(self.log_path, metric)
        return response['result']

    def close(self):
        if self._ws is not None:
            try:
                self._ws.close()
            except Exception:
                pass
            self._ws = None


HybridClientPolicy = HybridClient