import asyncio
import logging
from aiohttp.web import Application, WebSocketResponse, json_response
from aiohttp.http_websocket import WSMsgType, WSCloseCode
from .node import Conductor


PORT = 7954


class WebSocketLogHandler(logging.Handler):

    def __init__(self, send_message):
        super().__init__()
        self.send_message = send_message

    def emit(self, record):
        try:
            self.send_message({
                'type': 'log',
                'name': record.name,
                'message': self.format(record)
            })
        except Exception:
            self.handleError(record)


class TestingServiceAPI:

    def __init__(self, stack: Conductor, loop: asyncio.AbstractEventLoop):
        self.stack = stack
        self.loop = loop
        self.app = Application()
        self.app.router.add_post('/start', self.start_stack)
        self.app.router.add_post('/generate', self.generate)
        self.app.router.add_post('/transfer', self.transfer)
        self.app.router.add_post('/balance', self.balance)
        self.app.router.add_get('/log', self.log)
        self.app['websockets'] = set()
        self.app.on_shutdown.append(self.on_shutdown)
        self.handler = self.app.make_handler()
        self.server = None

    async def start(self):
        self.server = await self.loop.create_server(
            self.handler, '0.0.0.0', PORT
        )
        print('serving on', self.server.sockets[0].getsockname())

    async def stop(self):
        await self.stack.stop()
        self.server.close()
        await self.server.wait_closed()
        await self.app.shutdown()
        await self.handler.shutdown(60.0)
        await self.app.cleanup()

    async def start_stack(self, _):
        handler = WebSocketLogHandler(self.send_message)
        logging.getLogger('blockchain').setLevel(logging.DEBUG)
        logging.getLogger('blockchain').addHandler(handler)
        logging.getLogger('electrumx').setLevel(logging.DEBUG)
        logging.getLogger('electrumx').addHandler(handler)
        logging.getLogger('Controller').setLevel(logging.DEBUG)
        logging.getLogger('Controller').addHandler(handler)
        logging.getLogger('LBRYBlockProcessor').setLevel(logging.DEBUG)
        logging.getLogger('LBRYBlockProcessor').addHandler(handler)
        logging.getLogger('LBCDaemon').setLevel(logging.DEBUG)
        logging.getLogger('LBCDaemon').addHandler(handler)
        logging.getLogger('torba').setLevel(logging.DEBUG)
        logging.getLogger('torba').addHandler(handler)
        logging.getLogger(self.stack.ledger_module.__name__).setLevel(logging.DEBUG)
        logging.getLogger(self.stack.ledger_module.__name__).addHandler(handler)
        logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).setLevel(logging.DEBUG)
        logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).addHandler(handler)
        #await self.stack.start()
        self.stack.blockchain_started or await self.stack.start_blockchain()
        self.send_message({'type': 'service', 'name': 'blockchain'})
        self.stack.spv_started or await self.stack.start_spv()
        self.send_message({'type': 'service', 'name': 'spv'})
        self.stack.wallet_started or await self.stack.start_wallet()
        self.send_message({'type': 'service', 'name': 'wallet'})
        self.stack.wallet_node.ledger.on_header.listen(self.on_status)
        self.stack.wallet_node.ledger.on_transaction.listen(self.on_status)
        return json_response({'started': True})

    async def generate(self, request):
        data = await request.post()
        blocks = data.get('blocks', 1)
        await self.stack.blockchain_node.generate(int(blocks))
        return json_response({'blocks': blocks})

    async def transfer(self, request):
        data = await request.post()
        address = data.get('address')
        if not address:
            address = await self.stack.wallet_node.account.receiving.get_or_create_usable_address()
        amount = data.get('amount', 1)
        txid = await self.stack.blockchain_node.send_to_address(address, amount)
        await self.stack.wallet_node.ledger.on_transaction.where(
            lambda e: e.tx.id == txid and e.address == address
        )
        return json_response({
            'address': address,
            'amount': amount,
            'txid': txid
        })

    async def balance(self, _):
        return json_response({
            'balance': await self.stack.blockchain_node.get_balance()
        })

    async def log(self, request):
        ws = WebSocketResponse()
        await ws.prepare(request)
        self.app['websockets'].add(ws)
        try:
            async for msg in ws:
                if msg.type == WSMsgType.TEXT:
                    if msg.data == 'close':
                        await ws.close()
                elif msg.type == WSMsgType.ERROR:
                    print('ws connection closed with exception %s' %
                          ws.exception())
        finally:
            self.app['websockets'].remove(ws)
        return ws

    @staticmethod
    async def on_shutdown(app):
        for ws in app['websockets']:
            await ws.close(code=WSCloseCode.GOING_AWAY, message='Server shutdown')

    async def on_status(self, _):
        if not self.app['websockets']:
            return
        self.send_message({
            'type': 'status',
            'height': self.stack.wallet_node.ledger.headers.height,
            'balance': await self.stack.wallet_node.account.get_balance(),
            'miner': await self.stack.blockchain_node.get_balance()
        })

    def send_message(self, msg):
        for ws in self.app['websockets']:
            asyncio.ensure_future(ws.send_json(msg))