import asyncio
import json
import os
import socket
import subprocess

import websockets
from pyfzf.pyfzf import FzfPrompt

from celilo.actions import ACTION_REALM_CONNECT, ACTION_REALM_CAPABILITIES, ACTION_REALM_QUERY
from celilo.network_config import HOST, PORT
from celilo.test_suite import pixel

fzf = FzfPrompt()

device = pixel

request = {
    "action": ACTION_REALM_CONNECT,
    "data": device,
    "sender": device
}
realm_capabilities = {
    "action": ACTION_REALM_CAPABILITIES,
    "data": "",
    "sender": device
}
realm_query = {
    "action": ACTION_REALM_QUERY,
    "data": "",
    "sender": device
}


def format_data_array(json_map):
    data = []
    for key in json_map:
        data.append(json_map[key]["model"])
    if len(data) == 0:
        return None
    return json.dumps(data)


def get_data(message):
    return json.loads(json.loads(message))["data"]


async def main(fzf_ops='--height 40% --layout reverse --info inline --border'):
    async with websockets.connect(f"ws://{HOST}:{PORT}") as websocket:

        j = json.dumps(request)

        await websocket.send(j)
        message = await websocket.recv()
        android_device_map = json.loads(message)
        android_devices = format_data_array(android_device_map)
        if not android_devices:
            print("No connected android devices found")
            return
        print(f">>> {android_devices}")
        data = json.loads(android_devices)

        # get table from user input
        android_model = fzf.prompt(data, fzf_options=fzf_ops)[0]
        #
        # # find model in android_device_map
        android_device = None
        for key in android_device_map:
            device = android_device_map[key]
            if android_model == android_device_map[key]["model"]:
                android_device = device
                break

        print(f">>> {android_device}")
        realm_capabilities["sender"] = android_device['sender']
        await websocket.send(json.dumps(realm_capabilities))
        message = await websocket.recv()

        print(f"realm_capabilities {json.loads(message)}")

        tables = get_data(message)
        table = fzf.prompt(tables, fzf_options=fzf_ops)[0]

        new_query = realm_query
        new_query["data"] = table
        new_query["sender"] = android_device['sender']

        query = json.dumps(new_query)
        await websocket.send(query)

        query_results = await websocket.recv()
        results = json.loads(json.loads(query_results))["data"]
        rsplit = results.split("\n")
        row = fzf.prompt(rsplit, fzf_options=fzf_ops)
        print(str(row))

        # print(f">>> {str(json.dumps(results, indent=4, sort_keys=True))}")


if __name__ == "__main__":
    asyncio.run(main())