from typing import Tuple, List, Dict, Any, Optional
import asyncio
import json
import logging
import subprocess


async def list_envelopes(limit: int = 9999) -> Tuple[List[Dict[str, Any]], bool]:
    """
    Retrieve a list of email envelopes using the Himalaya CLI.

    Args:
        limit: Maximum number of envelopes to retrieve

    Returns:
        Tuple containing:
        - List of envelope dictionaries
        - Success status (True if operation was successful)
    """
    try:
        process = await asyncio.create_subprocess_shell(
            f"himalaya envelope list -o json -s {limit}",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        if process.returncode == 0:
            envelopes = json.loads(stdout.decode())
            return envelopes, True
        else:
            logging.error(f"Error listing envelopes: {stderr.decode()}")
            return [], False
    except Exception as e:
        logging.error(f"Exception during envelope listing: {e}")
        return [], False


async def list_accounts() -> Tuple[List[Dict[str, Any]], bool]:
    """
    Retrieve a list of accounts configured in Himalaya.

    Returns:
        Tuple containing:
        - List of account dictionaries
        - Success status (True if operation was successful)
    """
    try:
        process = await asyncio.create_subprocess_shell(
            "himalaya account list -o json",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        if process.returncode == 0:
            accounts = json.loads(stdout.decode())
            return accounts, True
        else:
            logging.error(f"Error listing accounts: {stderr.decode()}")
            return [], False
    except Exception as e:
        logging.error(f"Exception during account listing: {e}")
        return [], False


async def list_folders() -> Tuple[List[Dict[str, Any]], bool]:
    """
    Retrieve a list of folders available in Himalaya.

    Returns:
        Tuple containing:
        - List of folder dictionaries
        - Success status (True if operation was successful)
    """
    try:
        process = await asyncio.create_subprocess_shell(
            "himalaya folder list -o json",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        if process.returncode == 0:
            folders = json.loads(stdout.decode())
            return folders, True
        else:
            logging.error(f"Error listing folders: {stderr.decode()}")
            return [], False
    except Exception as e:
        logging.error(f"Exception during folder listing: {e}")
        return [], False


async def delete_message(message_id: int) -> bool:
    """
    Delete a message by its ID.

    Args:
        message_id: The ID of the message to delete

    Returns:
        True if deletion was successful, False otherwise
    """
    try:
        process = await asyncio.create_subprocess_shell(
            f"himalaya message delete {message_id}",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        return process.returncode == 0
    except Exception as e:
        logging.error(f"Exception during message deletion: {e}")
        return False


async def archive_message(message_id: int) -> bool:
    """
    Archive a message by its ID.

    Args:
        message_id: The ID of the message to archive

    Returns:
        True if archiving was successful, False otherwise
    """
    try:
        process = await asyncio.create_subprocess_shell(
            f"himalaya message archive {message_id}",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        return process.returncode == 0
    except Exception as e:
        logging.error(f"Exception during message archiving: {e}")
        return False


async def get_message_content(message_id: int) -> Tuple[Optional[str], bool]:
    """
    Retrieve the content of a message by its ID.

    Args:
        message_id: The ID of the message to retrieve
        format: The desired format of the message content ("html" or "text")

    Returns:
        Tuple containing:
        - Message content (or None if retrieval failed)
        - Success status (True if operation was successful)
    """
    try:
        cmd = f"himalaya message read {message_id}"

        process = await asyncio.create_subprocess_shell(
            cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await process.communicate()

        if process.returncode == 0:
            content = stdout.decode()
            return content, True
        else:
            logging.error(f"Error retrieving message content: {
                          stderr.decode()}")
            return None, False
    except Exception as e:
        logging.error(f"Exception during message content retrieval: {e}")
        return None, False


def sync_himalaya():
    """Synchronize data using Himalaya."""
    try:
        # subprocess.run(["himalaya", "sync"], check=True)
        print("Himalaya sync completed successfully.")
    except subprocess.CalledProcessError as e:
        print(f"Error during Himalaya sync: {e}")