import aiohttp
import logging
from typing import Optional, Dict, Any
from config import (
    MIKOPBX_HOST, 
    MIKOPBX_API_TOKEN,
    MIKOPBX_ADMIN_LOGIN, 
    MIKOPBX_ADMIN_PASSWORD
)

logger = logging.getLogger(__name__)

class MikoPBXService:
    def __init__(self):
        self.host = MIKOPBX_HOST.rstrip('/')
        self.api_token = MIKOPBX_API_TOKEN
        self.admin_login = MIKOPBX_ADMIN_LOGIN
        self.admin_password = MIKOPBX_ADMIN_PASSWORD
        self.session = None

    async def _get_session(self):
        if self.session is None:
            self.session = aiohttp.ClientSession()
        return self.session

    def _get_auth_headers(self) -> Dict[str, str]:
        """Возвращает заголовки авторизации (Bearer Token в приоритете)"""
        headers = {
            "Content-Type": "application/json",
            "Accept": "application/json"
        }
        
        if self.api_token:
            headers["Authorization"] = f"Bearer {self.api_token}"
        elif self.admin_login and self.admin_password:
            import base64
            credentials = f"{self.admin_login}:{self.admin_password}"
            encoded = base64.b64encode(credentials.encode()).decode()
            headers["Authorization"] = f"Basic {encoded}"
        
        return headers

    async def _make_request(self, method: str, endpoint: str, json_data: Optional[Dict] = None, params: Optional[Dict] = None):
        """Выполняет запрос к MikoPBX REST API v3"""
        session = await self._get_session()
        url = f"{self.host}{endpoint}"
        headers = self._get_auth_headers()

        try:
            if method.upper() == "GET":
                async with session.get(url, params=params, headers=headers) as resp:
                    return await resp.json()
            elif method.upper() == "DELETE":
                async with session.delete(url, headers=headers) as resp:
                    return await resp.json()
            else:
                async with session.post(url, json=json_data, headers=headers) as resp:
                    return await resp.json()
                    
        except Exception as e:
            logger.error(f"API request error: {e}")
            return {"result": False, "messages": [str(e)]}

    # ==================== EXTENSIONS ====================

    async def get_extension_template(self) -> Optional[Dict]:
        """Получить шаблон нового сотрудника (API v3)"""
        response = await self._make_request("GET", "/pbxcore/api/v3/extensions")
        if response.get("result"):
            return response.get("data")
        logger.error(f"Failed to get template: {response.get('messages')}")
        return None

    async def create_extension(self, number: str, secret: str = None, username: str = "", email: str = "") -> Dict[str, Any]:
        """Создать нового SIP сотрудника (API v3)"""
        template = await self.get_extension_template()
        if not template:
            return {"success": False, "error": "Failed to get template"}

        # Заполняем шаблон
        template["number"] = number
        if username:
            template["user_username"] = username
        if email:
            template["user_email"] = email
        template["type"] = "SIP"
        template["show_in_phonebook"] = "1"
        template["is_general_user_number"] = "1"

        if secret:
            template["sip_secret"] = secret

        response = await self._make_request(
            "POST",
            "/pbxcore/api/v3/extensions",
            json_data=template
        )
        
        if response.get("result"):
            return {
                "success": True,
                "number": number,
                "data": response.get("data", {})
            }
        else:
            return {
                "success": False,
                "error": response.get("messages", ["Unknown error"])
            }

    async def get_extension(self, number: str) -> Optional[Dict]:
        """Получить сотрудника по номеру"""
        response = await self._make_request(
            "GET", 
            f"/pbxcore/api/v3/extensions/{number}"
        )
        if response.get("result"):
            return response.get("data")
        return None

    async def set_extension_secret(self, number: str, new_secret: str) -> Dict[str, Any]:
        """Обновить пароль"""
        current = await self.get_extension(number)
        if not current:
            return {"success": False, "error": "Extension not found"}

        current["sip_secret"] = new_secret

        response = await self._make_request(
            "PUT",
            f"/pbxcore/api/v3/extensions/{number}",
            json_data=current
        )
        
        return {
            "success": response.get("result", False),
            "messages": response.get("messages", [])
        }

    async def change_extension_number(self, old_number: str, new_number: str) -> Dict[str, Any]:
        """Сменить номер (удалить + создать заново)"""
        current = await self.get_extension(old_number)
        if not current:
            return {"success": False, "error": "Extension not found"}

        old_secret = current.get("sip_secret", "")

        # Удаляем старый
        delete_resp = await self._make_request(
            "DELETE", 
            f"/pbxcore/api/v3/extensions/{old_number}"
        )
        
        if not delete_resp.get("result"):
            return {"success": False, "error": "Failed to delete old extension"}

        # Создаём новый
        current["number"] = new_number
        current.pop("id", None)
        current.pop("sip_uniqid", None)

        create_resp = await self._make_request(
            "POST",
            "/pbxcore/api/v3/extensions",
            json_data=current
        )
        
        if create_resp.get("result"):
            return {
                "success": True,
                "old_number": old_number,
                "new_number": new_number,
                "secret": old_secret
            }
        
        return {"success": False, "error": "Failed to create new extension"}

    async def delete_extension(self, number: str) -> Dict[str, Any]:
        """Удалить сотрудника"""
        response = await self._make_request(
            "DELETE", 
            f"/pbxcore/api/v3/extensions/{number}"
        )
        return {
            "success": response.get("result", False),
            "messages": response.get("messages", [])
        }

    async def close(self):
        if self.session:
            await self.session.close()