%pip install -r requirements.txt

import os
from abc import ABC, abstractmethod
from typing import Optional, Dict, Any, Union
from dataclasses import dataclass
import requests
import json
from enum import Enum
from dotenv import load_dotenv

class ServerStatus(str, Enum):
    RUNNING = "running"
    STOPPED = "stopped"
    STARTING = "starting"

@dataclass
class EngeeConfig:
    """Configuration of the connection to Engee."""
    pat: str
    base_url: str = "https://engee.com"
    timeout: float = 36000.0  # Default idle timeout, seconds
    # serverName: str = "demo00000000-engeeid"


class IEngeeAPI(ABC):
    """An abstract interface for the Engee API."""

    @abstractmethod
    def get_server_info(self) -> Optional[Dict[str, Any]]:
        pass

    @abstractmethod
    def start_server(self) -> Optional[Dict[str, Any]]:
        pass

    @abstractmethod
    def stop_server(self) -> bool:
        pass

    @abstractmethod
    def execute_command(self, command: str) -> Optional[str]:
        pass

    @abstractmethod
    def upload_file(self, destination_path: str, local_path: str) -> bool:
        pass


class EngeeAPI(IEngeeAPI):
    """Implementation of an API for interacting with Engee."""

    def __init__(self, config: EngeeConfig):
        self.config = config
        self._headers = {"Authorization": f"Bearer {config.pat}"}

    def _make_request(self, method: str, url: str, **kwargs) -> Optional[requests.Response]:
        """An internal method for executing HTTP requests."""
        try:
            response = requests.request(method, url, headers=self._headers, **kwargs)
            return response if response.status_code < 400 else None
        except requests.exceptions.RequestException as e:
            print(f"Request error: {e}")
            return None

    def get_server_info(self) -> Optional[Dict[str, Any]]:
        """Get information about the server status."""
        info_url = f"{self.config.base_url}/account/api/engee/info"
        response = self._make_request("GET", info_url)
        return response.json() if response else None

    def start_server(self) -> Optional[Dict[str, Any]]:
        """Start the server."""
        info = self.get_server_info()
        if not info or info.get("serverStatus") != ServerStatus.STOPPED:
            print("The server is not in the 'stopped' state, startup is not possible.")
            return None

        start_url = f"{self.config.base_url}/account/api/engee/start"
        payload = {
            "url": info["url"],
            "inactivityTimeout": self.config.timeout
        }
        headers = {**self._headers, "Content-Type": "application/json"}

        response = self._make_request("POST", start_url, json=payload)
        return response.json() if response else None

    def stop_server(self) -> bool:
        """Stop the server."""
        stop_url = f"{self.config.base_url}/account/api/engee/stop"
        response = self._make_request("DELETE", stop_url)
        success = response is not None and response.status_code == 204
        if success:
            print("The server is stopped")
        return success

    def execute_command(self, command: str) -> Optional[str]:
        """Run the command on the server."""
        info = self.get_server_info()
        if not info:
            print("Couldn't get information about the server.")
            return None

        if info.get("serverStatus") != ServerStatus.RUNNING:
            status = info.get("serverStatus")
            if status == ServerStatus.STOPPED:
                print("The server is not running. Use the `start_server()` command to start the server.")
            else:
                print("The server is starting. Please try again later.")
            return None

        server_url = f"{self.config.base_url}{info['url']}"
        eval_url = f"{server_url}/external/command/eval"
        payload = {"command": command}
        headers = {**self._headers, "Content-Type": "application/json"}

        response = self._make_request("POST", eval_url, json=payload)
        if response and response.status_code == 201:
            result = response.json().get("result")
            print(result)
            return result
        else:
            print("No result")
            return None

    def upload_file(self, destination_path: str, local_path: str) -> bool:
        """Upload the file to the server."""
        if not os.path.isfile(local_path):
            raise FileNotFoundError(f"File not found: {local_path}")

        info = self.get_server_info()
        if not info:
            print("Couldn't get information about the server.")
            return False

        if info.get("serverStatus") != ServerStatus.RUNNING:
            status = info.get("serverStatus")
            if status == ServerStatus.STOPPED:
                print("The server is not running. Use the `start_server()` command to start the server.")
            else:
                print("The server is starting. Please try again later.")
            return False

        server_url = f"{self.config.base_url}{info['url']}"
        upload_url = f"{server_url}/external/file/upload"
        filename = os.path.basename(local_path)

        files = {
            'paths': (None, json.dumps({"sources": [destination_path]})),
            'upload_files': (filename, open(local_path, 'rb'))
        }

        try:
            headers = {**self._headers} 
            response = self._make_request("POST", upload_url, files=files)
            if response:
                if response.status_code == 201:
                    print("Uploaded successfully")
                    return True
                elif response.status_code == 200:
                    print(f"A file with that name exists. The uploaded file has been named {response.text}")
                    return True
                else:
                    print(f"Error: {response.status_code} – {response.text}")
            return False
        finally:
            if 'upload_files' in files and hasattr(files['upload_files'][1], 'close'):
                files['upload_files'][1].close()
    
    def download(self, remote_path: Union[str, list[str]], local_save_path: str) -> bool:
        """
        A universal download method.
        :param remote_path: string (single file) or list of strings (multiple files)
        :param local_save_path: local path to save (file or ZIP)
        :return: True on success, False on error
        """

        # Determining whether one path has been passed or several
        if isinstance(remote_path, str):
            paths_to_download = [remote_path]
            single_file_mode = True
        elif isinstance(remote_path, list):
            paths_to_download = remote_path
            single_file_mode = False
        else:
            print("Error: remote_path must be a string or a list of strings.")
            return False

        # We check that all paths start with '/user/'
        for path in paths_to_download:
            if not path.startswith('/user/'):
                print(f"Error: All paths must start with '/user/'. Specified: {path}")
                return False

        info = self.get_server_info()
        if not info:
            print("Couldn't get information about the server.")
            return False

        if info.get("serverStatus") != ServerStatus.RUNNING:
            status = info.get("serverStatus")
            if status == ServerStatus.STOPPED:
                print("The server is not running. Use the `start_server()` command to start the server.")
            else:
                print("The server is starting up. Please try again later.")
            return False

        server_url = f"{self.config.base_url}{info['url']}"
        download_url = f"{server_url}/external/file/download"

        payload = {"sources": paths_to_download}

        try:
            response = self._make_request("POST", download_url, json=payload)
            if not response:
                print("The download request failed.")
                return False

            if response.status_code == 404:
                print(f"One or more files from the list do not exist on the server: {paths_to_download}")
                return False

            if response.status_code == 403:
                print(f"One or more files violate the rule: they must be inside /user/. Check: {paths_to_download}")
                return False

            if response.status_code != 200:
                print(f"Error when downloading: {response.status_code} – {response.text}")
                return False

            # Creating a directory to save
            os.makedirs(os.path.dirname(local_save_path), exist_ok=True)

            content_type = response.headers.get('Content-Type', '')

            if single_file_mode:
                # Download as a single file
                with open(local_save_path, 'wb') as f:
                    f.write(response.content)
                print(f"File '{remote_path}' successfully downloaded to '{local_save_path}'")
            else:
                # Download as a ZIP archive
                if 'application/x-zip-compressed' not in content_type and 'zip' not in content_type:
                    print(f"Warning: The response is not a ZIP archive. Content-Type: {content_type}")

                with open(local_save_path, 'wb') as f:
                    f.write(response.content)
                print(f"Archive with files successfully downloaded to '{local_save_path}'")

            return True

        except Exception as e:
            print(f"Error when downloading: {e}")
            return False

class EngeeManager:
    """The main class for managing Engee"""

    def __init__(self, config: EngeeConfig):
        self.api = EngeeAPI(config)

    def get_status(self) -> Optional[ServerStatus]:
        """Get the current server status."""
        info = self.api.get_server_info()
        if info:
            status_str = info.get("serverStatus")
            try:
                return ServerStatus(status_str)
            except ValueError:
                return None
        return None

    def start(self) -> Optional[Dict[str, Any]]:
        """Start the server."""
        return self.api.start_server()

    def stop(self) -> bool:
        """Stop the server."""
        return self.api.stop_server()

    def command(self, command: str) -> Optional[str]:
        """Run the command on the server."""
        return self.api.execute_command(command)

    def upload(self, destination_path: str, local_path: str) -> bool:
        """Upload the file to the server."""
        return self.api.upload_file(destination_path, local_path)
    
    def download(self, remote_path: Union[str, list[str]], local_save_path: str) -> bool:
        """
        Universal download method: one file or several.
        :param remote_path: string or list of strings
        :param local_save_path: where to save
        """
        return self.api.download(remote_path, local_save_path)


def load_config_from_env(env_file: str = ".env") -> EngeeConfig:
    """Download the configuration from the .env file."""
    try:
        load_dotenv()
    except ImportError:
        print("The python-dotenv library is not installed. Skipping the download of .env.")

    pat = os.environ.get("ENGEE_PAT")
    if not pat:
        raise ValueError("The ENGEE_PAT environment variable was not found.")

    return EngeeConfig(pat=pat)

config = load_config_from_env()
manager = EngeeManager(config)

print(f"Current status: {manager.get_status()}")

manager.start()
print(f"Current status: {manager.get_status()}")

manager.command("pwd()")

manager.start()

print(f"Current status: {manager.get_status()}")
pwd = manager.command("pwd()")
engee_version = manager.command("engee.version()")

upload_status = manager.upload("/user/upload_test/", r'D:\engee_api\upload_test\upload_test.txt')

files = manager.command('readdir("/user/upload_test/")')

upload_status = manager.upload("/user/upload_test/", r'D:\engee_api\upload_test\upload_test.txt')

files = manager.command('readdir("/user/upload_test/")')

manager.download("/user/upload_test/upload_test_1.txt", r"D:\engee_api\download_test\download_test.txt")

manager.download(
        files,
        r"D:\engee_api\download_test\download_test.zip"
    )

manager.download(
        ["/user/upload_test/upload_test.txt", "/user/upload_test/upload_test_1.txt"],
        r"D:\engee_api\download_test\download_test.zip"
    )

stop_status = manager.stop()
print(f"Current status: {manager.get_status()}")

pwd = manager.command("pwd()")