import asyncio
import binascii
from collections import deque, OrderedDict
import logging
import socket
import struct

from aiojsonrpc2 import ServerProtocol, ClientProtocol

from ..errors import *

logger = logging.getLogger(__name__)


class BaseWorkerProtocol(ServerProtocol):
    pool = None
    pool_watchdog_fut = None

    registered_extra_nonce1_tails = set()

    # we'll optionally track the most recent n shares/solutions
    # for duplicate detection; this needs to be 'enabled' in
    # hook_validate_share_params by adding 'unique' data to be
    # checked (which likely differs by algo/coin)
    recent_shares = deque(maxlen=500)

    def __init__(self, proxy, connection_settings, *args, **kwargs):
        self.proxy = proxy
        self.settings = kwargs
        self.log_prefix = 'W:{}:'.format(self.proxy.name)

        super().__init__(connection_settings)

        mw = self.settings.get('max_workers')
        if mw is None:
            self.max_workers = 256
            logger.info("{} defaulting to {} max workers".format(self.log_prefix, mw, self.max_workers))
        else:
            try:
                self.max_workers = int(mw)
                if self.max_workers not in [1, 256, 65536]:
                    raise ValueError
            except (ValueError, TypeError):
                self.max_workers = 256
                logger.warning("{} invalid 'max_workers' setting ({}), defaulting to {} instead".format(self.log_prefix, mw, self.max_workers))

        if self.max_workers != 1:
            logger.info("{} up to {} workers supported (distinct nonce spaces)".format(self.log_prefix, self.max_workers))
        else:
            logger.info("{} solo worker mode (single nonce space)".format(self.log_prefix, self.max_workers))

    async def pool_watchdog(self):
        while not self.stopping:
            await asyncio.sleep(1)

            # only try to reconnect to the pool if we have existing client
            # connections
            if len(self.clients) and not self.pool.connected:
                while True:
                    try:
                        await self.pool.connect()
                        break
                    except:
                        if self.stopping:
                            return
                        await self.pool.use_next_pool_config()

                await self.pool.initialize()
                self.pool.set_ready()

    async def initialize(self):
        self.pool = self.proxy.pool
        self.pool_watchdog_fut = asyncio.ensure_future(self.pool_watchdog())

    async def loop(self, connection):
        _socket = connection.reader._transport.get_extra_info('socket')

        try:
            if hasattr(socket, 'SOL_SOCKET') and hasattr(socket, 'SO_KEEPALIVE'):
                _socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # Enable keepalive packets
            if hasattr(socket, 'SOL_TCP'):
                if hasattr(socket, 'TCP_KEEPIDLE'):
                    # Seconds before sending keepalive probes
                    _socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 60)
                if hasattr(socket, 'TCP_KEEPINTVL'):
                    # Interval in seconds between keepalive probes
                    _socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, 5)
                if hasattr(socket, 'TCP_KEEPCNT'):
                    # Failed keepalive probes before declaring other end dead
                    _socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, 20)
        except:
            # Some socket features are not available on all platforms (Windows and macOS!)
            logger.exception("{} unable to set socket keep-alive due to platform constraints".format(self.log_prefix))

        if not self.pool.connected or not self.pool.is_ready():
            self.recent_shares.clear()

            # wait until the pool is subscribed, authorized, etc
            await self.pool.wait_until_ready()

        try:
            connection.extra['extra_nonce1_tail'] = self.get_extra_nonce1_tail()
        except MaxClientsConnected:
            await self.close_connection(connection)
            # connection.close()
            # self.client_connections.remove(connection)
            # self.cleanup_connection(connection)
            logger.warning("{} maximum number of {} workers reached, disconnecting".format(
                self.log_prefix, len(self.clients)))
            return

        connection.extra['subscriptions'] = {}

        await super().loop(connection)

    def cleanup_connection(self, connection):
        tail = connection.extra.get('extra_nonce1_tail')
        if tail:
            try:
                self.registered_extra_nonce1_tails.remove(tail)
            except:
                pass

    async def close(self):
        await super().close()
        await self.pool_watchdog_fut

    def get_extra_nonce1_tail(self):
        if self.max_workers != 1:
            if self.max_workers == 65536:
                # 2 bytes allows for 65536 (0000 through FFFF)
                _format = '>H'
            else:
                # 1 byte allows for 256 workers (00 through FF)
                _format = '>B'

            for i in range(0, self.max_workers):
                tail = binascii.hexlify(struct.pack(_format, i)).decode('ascii')

                if tail not in self.registered_extra_nonce1_tails:
                    self.registered_extra_nonce1_tails.add(tail)
                    return tail

            raise MaxClientsConnected


class BasePoolProtocol(ClientProtocol):
    workers = None

    pool_configs = []

    ready = asyncio.Event()

    subscriptions = {}
    extra_nonce1 = None
    extra_nonce2_size = None

    target_difficulty = None

    jobs = OrderedDict()
    current_job = None

    authorized_workers = {}
    unauthorized_workers = set()

    def __init__(self, proxy, connection_settings, *args, **kwargs):
        self.proxy = proxy
        self.settings = kwargs

        if isinstance(connection_settings, dict):
            self.pool_configs = [connection_settings]
        else:
            self.pool_configs = connection_settings

        self.log_prefix = 'P:{}:'.format(self.proxy.name)
        # start things up with the first pool configuration in the list!
        super().__init__(self.pool_configs.pop(0))

    async def use_next_pool_config(self):
        # If we get here, there was a pool disconnection and we should
        # try the next pool and/or exponentially back off our reconnection
        # attempts (local internet disconnection, perhaps???)

        # reset the ready indicator
        self.ready.clear()

        try:
            next_config = self.pool_configs.pop(0)
        except IndexError:
            # There wasn't another pool configuration available (no fallback pool!)
            next_config = None

            # No other pool to connect to, so let's wait a few seconds and
            # try to reconnect to the current and only pool settings
            logger.warning("{} waiting 10 seconds before reconnecting to current pool".format(self.log_prefix))
            await asyncio.sleep(10)

        if next_config:
            # Store the current (disconnected) config back in our pool config list
            self.pool_configs.append(self.connection_settings)
            # Switch to the next config!
            self.set_connection_config(next_config)

    async def initialize(self):
        self.workers = self.proxy.workers

    def is_ready(self):
        return self.ready.is_set()

    def set_ready(self):
        if not self.ready.is_set():
            self.ready.set()

    async def wait_until_ready(self):
        await self.ready.wait()

    def set_extra_nonce_data(self, extra_nonce1, extra_nonce2_size=None):
        self.extra_nonce1 = extra_nonce1
        self.extra_nonce2_size = extra_nonce2_size

    async def loop(self, connection):
        await super().loop(connection)

        if not self.stopping:
            # All client connections will need to be closed so they
            # auto-reconnect to resubscribe for the new nonce, etc
            await self.workers.close_all_connections()

            self.jobs.clear()
            self.current_job = None

            self.authorized_workers.clear()
            self.unauthorized_workers.clear()

            await self.use_next_pool_config()

    # async def _DELETE_THIS_test_method(self):
    #     await asyncio.sleep(4)
    #     logger.critical("{} kill connection for testing purposes".format(self.log_prefix))
    #     if self.connected:
    #         await self.connection.close()
    #         self.cleanup_connection(self.connection)
    #         self.connection = None
    #
    # # TODO DELETE this override
    # async def connect(self):
    #     await super().connect()
    #     asyncio.ensure_future(self._DELETE_THIS_test_method())
