#!/usr/bin/env python3
import argparse
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timedelta, timezone
import json
import math
import secrets
import shutil
import socket
import struct
import subprocess
import sys
import time


TARGETS = ('109.248.5.186', '109.248.5.56')
JAVA_PORT = 25565
BEDROCK_PORT = 19132
TIMEOUT = 1.7
Moscow = timezone(timedelta(hours=3))
RAKNET_MAGIC = bytes.fromhex('00ffff00fefefefefdfdfdfd12345678')


def var_int(value):
    encoded = bytearray()
    while value >= 128:
        encoded.append((value & 127) | 128)
        value >>= 7
    encoded.append(value)
    return bytes(encoded)


def read_var_int(stream):
    value = 0
    for shift in range(0, 35, 7):
        octet = stream.read(1)
        if not octet:
            raise ValueError('Игровой сервер закрыл соединение.')
        value |= (octet[0] & 127) << shift
        if not octet[0] & 128:
            return value
    raise ValueError('Некорректный ответ игрового сервера.')


def java_status(address):
    name = address.encode('utf-8')
    handshake = b'\0' + var_int(774) + var_int(len(name)) + name + struct.pack('!H', JAVA_PORT) + b'\1'
    with socket.create_connection((address, JAVA_PORT), timeout=TIMEOUT) as client:
        client.sendall(var_int(len(handshake)) + handshake + b'\1\0')
        with client.makefile('rb') as stream:
            length = read_var_int(stream)
            if not 3 <= length <= 131072 or read_var_int(stream) != 0:
                raise ValueError('Сервер не вернул пакет Minecraft Status.')
            json_size = read_var_int(stream)
            if not 2 <= json_size <= length:
                raise ValueError('Некорректная длина Minecraft Status.')
            data = stream.read(json_size)
            if len(data) != json_size or not isinstance(json.loads(data), dict):
                raise ValueError('Ответ Minecraft Status не распознан.')


def bedrock_status(address):
    stamp = struct.pack('!Q', int(time.time() * 1000))
    request = b'\1' + stamp + RAKNET_MAGIC + secrets.token_bytes(8)
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client:
        client.settimeout(TIMEOUT)
        client.connect((address, BEDROCK_PORT))
        client.send(request)
        reply = client.recv(2048)
    if len(reply) < 35 or reply[0] != 28 or reply[1:9] != stamp or reply[17:33] != RAKNET_MAGIC:
        raise ValueError('Ответ Bedrock RakNet не распознан.')


def now():
    return datetime.now(Moscow).strftime('%d.%m.%Y %H:%M:%S.%f')[:-3] + ' МСК'


def probe(check, address):
    start = time.perf_counter()
    try:
        check(address)
        return now(), round((time.perf_counter() - start) * 1000), None
    except (OSError, ValueError) as error:
        detail = 'Тайм-аут ответа' if isinstance(error, socket.timeout) else str(error)
        return now(), None, detail


def copy_text(report):
    if sys.platform == 'win32':
        candidates = [('powershell.exe', '-NoProfile', '-NonInteractive', '-Command',
                       '[Console]::InputEncoding = [Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())')]
    else:
        candidates = [('termux-clipboard-set',), ('wl-copy',), ('xclip', '-selection', 'clipboard')]
    for command in candidates:
        if not shutil.which(command[0]):
            continue
        try:
            subprocess.run(command, input=report.encode('utf-8'), stdout=subprocess.DEVNULL,
                           stderr=subprocess.DEVNULL, timeout=3, check=True)
            return True
        except (OSError, subprocess.SubprocessError):
            continue
    return False


def main():
    parser = argparse.ArgumentParser(description='CubeHead | Проверка игровых портов')
    parser.add_argument('edition', nargs='?', choices=('Java', 'Bedrock'))
    parser.add_argument('--count', type=int, default=12, metavar='N', help='число проб на адрес, от 1 до 60')
    parser.add_argument('--nick', default='', help='ник для отчёта')
    parser.add_argument('--copy', action='store_true', help='скопировать отчёт, если доступен буфер обмена')
    args = parser.parse_args()
    if not 1 <= args.count <= 60:
        parser.error('--count должен быть от 1 до 60')
    edition = args.edition
    if edition is None:
        choice = input('Издание [1 - Java / 2 - Bedrock]: ').strip()
        edition = {'1': 'Java', '2': 'Bedrock'}.get(choice)
        if edition is None:
            parser.error('введите 1 или 2')

    nick = ''.join(c for c in args.nick if c.isprintable()).strip()[:32]
    check = java_status if edition == 'Java' else bedrock_status
    transport = f'TCP {JAVA_PORT}, Minecraft Status' if edition == 'Java' else f'UDP {BEDROCK_PORT}, RakNet'
    results = {address: [] for address in TARGETS}
    start = now()
    print(f'\nCubeHead | {edition} | {transport}', file=sys.stderr)
    with ThreadPoolExecutor(max_workers=2) as pool:
        for number in range(1, args.count + 1):
            round_start = time.monotonic()
            jobs = {address: pool.submit(probe, check, address) for address in TARGETS}
            for address, job in jobs.items():
                results[address].append(job.result())
            if sys.stderr.isatty():
                bar = '#' * math.ceil(number * 16 / args.count)
                print(f'\r[{bar:<16}] {number:>2}/{args.count}', end='', file=sys.stderr, flush=True)
            if number < args.count:
                time.sleep(max(0, 1 - (time.monotonic() - round_start)))
    if sys.stderr.isatty():
        print(file=sys.stderr)

    lines = ['CubeHead | Проверка игровых портов', f'Издание: {edition} | {transport}',
             f'Ник: {nick or "не указан"}', f'Время: {start} - {now()}',
             'Запросы отправлены напрямую с устройства игрока.']
    for address, samples in results.items():
        answers = sorted(ms for _, ms, error in samples if error is None)
        lines.extend(('', f'{address} | Ответов: {len(answers)}/{args.count}'))
        if answers:
            median = answers[math.ceil(len(answers) * .5) - 1]
            p95 = answers[math.ceil(len(answers) * .95) - 1]
            lines.append(f'Задержка медиана / p95: {median} / {p95} мс')
        lines.extend(f'{stamp} | {error}' for stamp, _, error in samples if error)
    lines.extend(('', 'Результат относится к запросам статуса игровых портов во время проверки.'))
    report = '\n'.join(lines)
    print(report)
    if args.copy:
        status = 'Отчёт скопирован.' if copy_text(report) else 'Буфер обмена недоступен. Скопируйте текст выше вручную.'
        print(status, file=sys.stderr)


if __name__ == '__main__':
    main()
