import aiohttp
import asyncio
import os
import requests
from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
from concurrent.futures import ThreadPoolExecutor

class StreamHG:
    BASE_URL = "https://streamhgapi.com/api"
    executor = ThreadPoolExecutor(max_workers=5)

    @staticmethod
    async def get_account_info(api_key):
        async with aiohttp.ClientSession() as session:
            try:
                async with session.get(f"{StreamHG.BASE_URL}/account/info?key={api_key}") as response:
                    return await response.json()
            except:
                return {"status": 0}

    @staticmethod
    async def get_upload_server(api_key):
        async with aiohttp.ClientSession() as session:
            try:
                async with session.get(f"{StreamHG.BASE_URL}/upload/server?key={api_key}") as response:
                    data = await response.json()
                    if data.get('status') == 200:
                        return data['result']
            except:
                pass
            return None

    @staticmethod
    def _blocking_upload(server_url, api_key, file_path, monitor_callback):
        filename = os.path.basename(file_path)
        encoder = MultipartEncoder(
            fields={
                'key': api_key,
                'file': (filename, open(file_path, 'rb'), 'application/octet-stream')
            }
        )
        monitor = MultipartEncoderMonitor(encoder, monitor_callback)
        headers = {'Content-Type': monitor.content_type}
        
        # Standard requests post, no chunk size needed as requests handles it well
        return requests.post(server_url, data=monitor, headers=headers).json()

    @staticmethod
    async def upload_file(api_key, file_path, progress_callback=None):
        server_url = await StreamHG.get_upload_server(api_key)
        if not server_url:
            return {"status": 500, "msg": "Could not get upload server"}

        loop = asyncio.get_running_loop()
        
        def monitor_callback(monitor):
            if progress_callback:
                asyncio.run_coroutine_threadsafe(
                    progress_callback(monitor.bytes_read, monitor.len),
                    loop
                )

        try:
            response = await loop.run_in_executor(
                StreamHG.executor,
                StreamHG._blocking_upload,
                server_url,
                api_key,
                file_path,
                monitor_callback
            )
            return response
        except Exception as e:
            return {"status": 500, "msg": str(e)}